← Back to branch summary

~ubuntu-branches/ubuntu/hardy/avidemux/hardy

« back to all changes in this revision

Viewing changes to avidemux/ADM_gui2/GUI_render.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Matvey Kozhev
  • Date: 2007-12-18 13:53:04 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071218135304-cdqec2lg2bglyz15
Tags: 1:2.4~preview3-0.0ubuntu1
https://launchpad.net/bugs/163287
https://launchpad.net/bugs/126572
https://launchpad.net/bugs/138854
* Upload to Ubuntu. (LP: #163287, LP: #126572)
* debian/changelog: re-added Ubuntu releases.
* debian/control:
  - Require debhelper >= 5.0.51 (for dh_icons) and imagemagick.
  - Build-depend on libsdl1.2-dev instead of libsdl-dev.
  - Build against newer libx264-dev. (LP: #138854)
  - Removed libamrnb-dev, not in Ubuntu yet.
* debian/rules:
  - Install all icon sizes, using convert (upstream installs none).
  - Added missing calls to dh_installmenu, dh_installman, dh_icons and
    dh_desktop.
* debian/menu, debian/avidemux-qt.menu:
  - Corrected package and executable names.
* debian/avidemux-common.install: Install icons.
* debian/avidemux.common.manpages: Install man/avidemux.1.
* debian/links, debian/avidemux-cli.links, debian/avidemux-gtk.links:
  - Link manpages to avidemux.1.gz.
* debian/install, debian/avidemux-qt.install, debian/avidemux-gtk.desktop,
  debian/avidemux-qt.desktop: Install desktop files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_gui2/GUI_render.cpp
1
 
/***************************************************************************
2
 
                          gui_render.cpp  -  description
3
 
 
4
 
        The final render a frame. The external interface is the same
5
 
        whatever the mean (RGB/YUV/Xv)
6
 
                             -------------------
7
 
    begin                : Thu Jan 3 2002
8
 
    copyright            : (C) 2002 by mean
9
 
    email                : fixounet@free.fr
10
 
 ***************************************************************************/
11
 
 
12
 
/***************************************************************************
13
 
 *                                                                         *
14
 
 *   This program is free software; you can redistribute it and/or modify  *
15
 
 *   it under the terms of the GNU General Public License as published by  *
16
 
 *   the Free Software Foundation; either version 2 of the License, or     *
17
 
 *   (at your option) any later version.                                   *
18
 
 *                                                                         *
19
 
 ***************************************************************************/
20
 
#include "config.h"
21
 
 
22
 
#include <stdio.h>         
23
 
#include <stdlib.h>
24
 
#include <math.h>
25
 
#include <unistd.h>
26
 
 
27
 
#include <gtk/gtk.h>
28
 
#include <time.h>
29
 
#include <sys/time.h>
30
 
 
31
 
 
32
 
#include "avi_vars.h"
33
 
#include <ADM_assert.h>
34
 
 
35
 
#include "prototype.h"
36
 
//#include "ADM_colorspace/colorspace.h"
37
 
//#include "ADM_gui/GUI_vars.h"
38
 
 
39
 
 
40
 
#include "ADM_gui2/GUI_render.h"
41
 
 
42
 
#include "ADM_gui2/GUI_accelRender.h"
43
 
#include "ADM_gui2/GUI_xvDraw.h"
44
 
#include "ADM_gui2/GUI_sdlDraw.h"
45
 
 
46
 
#include "ADM_toolkit/toolkit_gtk.h"
47
 
 
48
 
#include "prefs.h"
49
 
#include "ADM_colorspace/ADM_rgb.h"
50
 
#include "ADM_libswscale/ADM_mp.h"
51
 
#include "gtkgui.h"
52
 
 
53
 
 
54
 
static uint8_t  updateWindowSize(GtkWidget * win, uint32_t w, uint32_t h);
55
 
 
56
 
 
57
 
uint8_t  GUI_InitRender (GtkWidget *g, uint32_t w,uint32_t h);
58
 
static renderZoom zoom=ZOOM_1_1;
59
 
 
60
 
static ColYuvRgb rgbConverter(640,480);
61
 
 
62
 
extern GtkWidget *getDrawWidget( void );
63
 
extern uint8_t UI_shrink(uint32_t w,uint32_t h);
64
 
static AccelRender *accel_mode=NULL;
65
 
//_______________________________________
66
 
 
67
 
static uint8_t          *screenBuffer=NULL;
68
 
static ADMImage                 *resized=NULL;
69
 
static ADM_MplayerResize         *resizer=NULL;
70
 
static uint8_t           *lastImage=NULL;
71
 
static GtkWidget        *draw=NULL;
72
 
static uint32_t         renderW=0,renderH=0;
73
 
 
74
 
//_______________________________________
75
 
/**
76
 
        Render init, initialize internals. Constuctor like function
77
 
 
78
 
*/
79
 
uint8_t renderInit( void )
80
 
{
81
 
        draw=getDrawWidget(  );
82
 
        return 1;
83
 
}
84
 
 
85
 
/**
86
 
        Warn the renderer that the display size is changing
87
 
 
88
 
*/
89
 
//----------------------------------------
90
 
uint8_t renderResize(uint32_t w, uint32_t h,renderZoom newzoom)
91
 
{
92
 
int mul,xx,yy;
93
 
 
94
 
        if(screenBuffer) 
95
 
                {
96
 
                        delete  [] screenBuffer;
97
 
                        screenBuffer=NULL;
98
 
                }
99
 
        if(resized)
100
 
        {
101
 
                        delete resized;
102
 
                        resized=NULL;
103
 
        }
104
 
        if(resizer)
105
 
        {
106
 
                delete resizer;
107
 
                resizer=NULL;
108
 
        }
109
 
        zoom=newzoom;
110
 
        switch(zoom)
111
 
        {
112
 
                case ZOOM_1_4: mul=1;break;
113
 
                case ZOOM_1_2: mul=2;break;
114
 
                case ZOOM_1_1: mul=4;break;
115
 
                case ZOOM_2:   mul=8;break;
116
 
                case ZOOM_4:   mul=16;break;
117
 
                default : ADM_assert(0);
118
 
 
119
 
        }
120
 
        xx=(w*mul+3)/4;
121
 
        yy=(h*mul+3)/4;
122
 
 
123
 
        if(xx&1) xx++;
124
 
        if(yy&1) yy++;
125
 
 
126
 
        screenBuffer=new uint8_t[xx*yy*4];
127
 
 
128
 
        if(zoom!=ZOOM_1_1)
129
 
        {
130
 
                 resizer=new ADM_MplayerResize(w,h,xx,yy);
131
 
                 resized=new ADMImage(xx,yy);
132
 
        }
133
 
 
134
 
        updateWindowSize( draw,xx,yy);
135
 
        UI_purge();
136
 
        return 1;
137
 
 
138
 
}
139
 
/**
140
 
        Update the image and render it
141
 
        The width and hiehgt must NOT have changed
142
 
 
143
 
*/
144
 
//----------------------------------------
145
 
uint8_t renderUpdateImage(uint8_t *ptr)
146
 
{
147
 
        
148
 
        ADM_assert(screenBuffer);
149
 
        if(zoom!=ZOOM_1_1)
150
 
        {
151
 
                ADM_assert(resizer);
152
 
                ADM_assert(resized);
153
 
                resizer->resize(ptr,resized->data);
154
 
                lastImage=resized->data;
155
 
                ptr=lastImage;
156
 
        }
157
 
        else
158
 
        {
159
 
                lastImage=ptr;
160
 
        }
161
 
        if(!accel_mode)
162
 
                GUI_ConvertRGB(ptr,screenBuffer, renderW,renderH);
163
 
        renderRefresh();
164
 
        return 1;
165
 
 
166
 
}
167
 
/**
168
 
        Refresh the image from internal buffer / last image
169
 
        Used for example as call back for X11 events
170
 
 
171
 
*/
172
 
//_______________________________________________
173
 
uint8_t renderRefresh(void)
174
 
{
175
 
        if(!screenBuffer)
176
 
        {
177
 
                if(accel_mode) ADM_assert(0);
178
 
                return 0;
179
 
        }
180
 
 
181
 
        if(accel_mode)
182
 
        {
183
 
                accel_mode->display(lastImage, renderW, renderH);
184
 
                //GUI_XvRedraw();
185
 
        }
186
 
        else
187
 
                GUI_RGBDisplay(screenBuffer, renderW, renderH,draw);
188
 
    return 1;
189
 
}
190
 
 
191
 
uint8_t renderExpose(void)
192
 
{
193
 
        if(!screenBuffer)
194
 
        {
195
 
                if(accel_mode) ADM_assert(0);
196
 
                return 0;
197
 
        }
198
 
 
199
 
 
200
 
    if ( accel_mode)
201
 
    {   
202
 
                accel_mode->display(lastImage,renderW,renderH);
203
 
    }
204
 
    else
205
 
        GUI_RGBDisplay(screenBuffer, renderW, renderH,draw);
206
 
    return 1;
207
 
 
208
 
}
209
 
uint8_t renderStartPlaying( void )
210
 
{
211
 
char *displ;
212
 
unsigned int renderI;
213
 
ADM_RENDER_TYPE render;
214
 
        ADM_assert(!accel_mode);
215
 
        // First check if local
216
 
        // We do it in a very wrong way : If DISPLAY!=:0.0 we assume remote display
217
 
        // in that case we do not even try to use accel
218
 
        
219
 
        // Win32 does not have display
220
 
#ifndef CYG_MANGLING    
221
 
        displ=getenv("DISPLAY");
222
 
        if(!displ)
223
 
        {
224
 
                return 0;
225
 
        }
226
 
        if(strcmp(displ,":0") && strcmp(displ,":0.0"))
227
 
        {
228
 
                printf("Looks like remote display, no Xv :%s\n",displ);
229
 
                return 1;
230
 
        }
231
 
#endif  
232
 
 
233
 
        if(prefs->get(DEVICE_VIDEODEVICE,&renderI)!=RC_OK)
234
 
        {       
235
 
                render=RENDER_GTK;
236
 
        }else
237
 
        {
238
 
                render=(ADM_RENDER_TYPE)renderI;
239
 
        }
240
 
        switch(render)
241
 
        {
242
 
        
243
 
#if defined(USE_XV)
244
 
               case RENDER_XV:
245
 
                accel_mode=new XvAccelRender();
246
 
                if(!accel_mode->init(draw,renderW,renderH))
247
 
                {
248
 
                        delete accel_mode;
249
 
                        accel_mode=NULL;
250
 
                        printf("Xv init failed\n");
251
 
                }
252
 
                else
253
 
                {
254
 
                        printf("Xv init ok\n");
255
 
                }
256
 
                break;
257
 
#endif
258
 
#if defined(USE_SDL)
259
 
              case RENDER_SDL:
260
 
                printf("Trying SDL\n");
261
 
                accel_mode=new sdlAccelRender();
262
 
                if(!accel_mode->init(draw,renderW,renderH))
263
 
                {
264
 
                        delete accel_mode;
265
 
                        accel_mode=NULL;
266
 
                        printf("sdl init failed\n");
267
 
                }
268
 
                else
269
 
                {
270
 
                        printf("SDL init ok\n");
271
 
                }
272
 
                break;
273
 
#endif
274
 
                default:break;
275
 
        }
276
 
        if(!accel_mode)
277
 
        {
278
 
                rgbConverter.reset(renderW,renderH);
279
 
                printf("No accel used for rendering\n");
280
 
        }
281
 
        
282
 
        return 1;
283
 
}
284
 
 
285
 
 
286
 
uint8_t renderStopPlaying( void )
287
 
{
288
 
        if(accel_mode)
289
 
        {
290
 
                accel_mode->end();
291
 
                delete accel_mode;                              
292
 
        }
293
 
        accel_mode=NULL;        
294
 
        return 1;
295
 
}
296
 
 
297
 
 
298
 
//___________________________________________________________________________
299
 
//
300
 
//
301
 
uint8_t updateWindowSize(GtkWidget * win, uint32_t w, uint32_t h)
302
 
{
303
 
    ADM_assert(screenBuffer);
304
 
    renderW = w;
305
 
    renderH = h;
306
 
 
307
 
    // Shrink the main window
308
 
    // so that we do not leave blanks everywhere
309
 
    
310
 
    //***
311
 
  
312
 
     /*UI_purge();
313
 
     UI_shrink(w,h);
314
 
     UI_purge();
315
 
     */
316
 
    gtk_widget_set_usize(win, w, h);
317
 
    return 1;
318
 
}
319
 
 
320
 
uint8_t GUI_ConvertRGB(uint8_t * in, uint8_t * out, uint32_t w, uint32_t h)
321
 
{
322
 
    //COL_yv12rgb (w, h,in, out);
323
 
    rgbConverter.reset(w,h);
324
 
    rgbConverter.scale(in,out);
325
 
    return 1;
326
 
}
327
 
 
328
 
AccelRender::AccelRender( void)
329
 
{
330
 
}
331
 
 
332
 
void GUI_RGBDisplay(uint8_t * dis, uint32_t w, uint32_t h, void *widg)
333
 
{
334
 
    GtkWidget *widget;
335
 
    widget = (GtkWidget *)widg; 
336
 
    //return;
337
 
 
338
 
 
339
 
    gdk_draw_rgb_32_image(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL], 0,    // X
340
 
                       0,       // y
341
 
                       w,       //width
342
 
                       h,       //h*2, // heigth
343
 
                       GDK_RGB_DITHER_NONE,
344
 
                       //GDK_RGB_DITHER_MAX,  // dithering
345
 
                       (guchar *) dis,  // buffer
346
 
                       w * 4);
347
 
 
348
 
 
349
 
}