Subversion Repositories Kolibri OS

Rev

Rev 5021 | Rev 5592 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 5021 Rev 5372
1 
#include
1 
#include
2 
#include
2 
#include
3 
#include
3 
#include
4 
#include
4 
#include
5 
#include
5 
#include
6 
#include
6 
#include
7 
#include "winlib/winlib.h"
 7 
#include "winlib/winlib.h"
8 
#include
8 
#include
9 
#include "fplay.h"
 9 
#include "fplay.h"
10 
#include
10 
#include
11 
 
 11 
 
12 
int fplay_blit_bitmap(bitmap_t *bitmap, int dst_x, int dst_y,int w, int h);
 12 
int fplay_blit_bitmap(bitmap_t *bitmap, int dst_x, int dst_y,int w, int h);
13 
 
 13 
 
14 
extern int res_pause_btn[];
 14 
extern int res_pause_btn[];
15 
extern int res_pause_btn_pressed[];
 15 
extern int res_pause_btn_pressed[];
16 
 
 16 
 
17 
extern int res_play_btn[];
 17 
extern int res_play_btn[];
18 
extern int res_play_btn_pressed[];
 18 
extern int res_play_btn_pressed[];
19 
 
 19 
 
20 
extern int64_t stream_duration;
 20 
extern int64_t stream_duration;
21 
extern volatile int sound_level_0;
 21 
extern volatile int sound_level_0;
22 
extern volatile int sound_level_1;
 22 
extern volatile int sound_level_1;
23 
 
 23 
 
24 
typedef struct
 24 
typedef struct
25 
{
 25 
{
26 
    AVPicture      picture;
 26 
    AVPicture      picture;
27 
    double         pts;
 27 
    double         pts;
28 
    volatile int   ready;
 28 
    volatile int   ready;
29 
}vframe_t;
 29 
}vframe_t;
30 
 
 30 
 
31 
vframe_t           frames[4];
 31 
vframe_t           frames[4];
32 
volatile int      frames_count = 0;
 32 
volatile int      frames_count = 0;
33 
 
 33 
 
34 
struct SwsContext *cvt_ctx = NULL;
 34 
struct SwsContext *cvt_ctx = NULL;
35 
 
 35 
 
36 
int vfx    = 0;
 36 
int vfx    = 0;
37 
int dfx    = 0;
 37 
int dfx    = 0;
38 
 
 38 
 
39 
render_t   *main_render;
 39 
render_t   *main_render;
40 
 
 40 
 
41 
int width;
 41 
int width;
42 
int height;
 42 
int height;
43 
 
 43 
 
44 
AVRational video_time_base;
 44 
AVRational video_time_base;
45 
AVFrame  *Frame;
 45 
AVFrame  *Frame;
46 
 
 46 
 
47 
volatile uint32_t driver_lock;
 47 
volatile uint32_t driver_lock;
48 
 
 48 
 
49 
void get_client_rect(rect_t *rc);
 49 
void get_client_rect(rect_t *rc);
50 
 
 50 
 
51 
void flush_video()
 51 
void flush_video()
52 
{
 52 
{
53 
    int i;
 53 
    int i;
54 
 
 54 
 
55 
    for(i = 0; i < 4; i++)
 55 
    for(i = 0; i < 4; i++)
56 
    {
 56 
    {
57 
        frames[i].pts    = 0;
 57 
        frames[i].pts    = 0;
58 
        frames[i].ready  = 0;
 58 
        frames[i].ready  = 0;
59 
    };
 59 
    };
60 
    frames_count = 0;
 60 
    frames_count = 0;
61 
    vfx    = 0;
 61 
    vfx    = 0;
62 
    dfx    = 0;
 62 
    dfx    = 0;
63 
};
 63 
};
64 
 
 64 
 
65 
int init_video(AVCodecContext *ctx)
 65 
int init_video(AVCodecContext *ctx)
66 
{
 66 
{
67 
    int        i;
 67 
    int        i;
68 
 
 68 
 
69 
    width = ctx->width;
 69 
    width = ctx->width;
70 
    height = ctx->height;
 70 
    height = ctx->height;
71 
 
 71 
 
72 
 
 72 
 
73 
    Frame = avcodec_alloc_frame();
 73 
    Frame = avcodec_alloc_frame();
74 
    if ( Frame == NULL )
 74 
    if ( Frame == NULL )
75 
    {
 75 
    {
76 
        printf("Cannot alloc video frame\n\r");
 76 
        printf("Cannot alloc video frame\n\r");
77 
        return 0;
 77 
        return 0;
78 
    };
 78 
    };
79 
 
 79 
 
80 
    for( i=0; i < 4; i++)
 80 
    for( i=0; i < 4; i++)
81 
    {
 81 
    {
82 
        int ret;
 82 
        int ret;
83 
 
 83 
 
84 
//        printf("alloc picture %d %d %x\n",
 84 
//        printf("alloc picture %d %d %x\n",
85 
//                   ctx->width, ctx->height, ctx->pix_fmt );
 85 
//                   ctx->width, ctx->height, ctx->pix_fmt );
86 
 
 86 
 
87 
        ret = avpicture_alloc(&frames[i].picture, ctx->pix_fmt,
 87 
        ret = avpicture_alloc(&frames[i].picture, ctx->pix_fmt,
88 
                               ctx->width, ctx->height);
 88 
                               ctx->width, ctx->height);
89 
        if ( ret != 0 )
 89 
        if ( ret != 0 )
90 
        {
 90 
        {
91 
            printf("Cannot alloc video buffer\n\r");
 91 
            printf("Cannot alloc video buffer\n\r");
92 
            return 0;
 92 
            return 0;
93 
        };
 93 
        };
94 
 
 94 
 
95 
        frames[i].pts    = 0;
 95 
        frames[i].pts    = 0;
96 
        frames[i].ready  = 0;
 96 
        frames[i].ready  = 0;
97 
    };
 97 
    };
98 
 
 98 
 
99 
    create_thread(video_thread, ctx, 1024*1024);
 99 
    create_thread(video_thread, ctx, 1024*1024);
100 
 
 100 
 
101 
    delay(50);
 101 
    delay(50);
102 
    return 1;
 102 
    return 1;
103 
};
 103 
};
104 
 
 104 
 
105 
int decode_video(AVCodecContext  *ctx, queue_t *qv)
 105 
int decode_video(AVCodecContext  *ctx, queue_t *qv)
106 
{
 106 
{
107 
    AVPacket   pkt;
 107 
    AVPacket   pkt;
108 
    double     pts;
 108 
    double     pts;
109 
    int frameFinished;
 109 
    int frameFinished;
110 
    double current_clock;
 110 
    double current_clock;
111 
 
 111 
 
112 
    if(frames[dfx].ready != 0 )
 112 
    if(frames[dfx].ready != 0 )
113 
        return -1;
 113 
        return -1;
114 
 
 114 
 
115 
    if( get_packet(qv, &pkt) == 0 )
 115 
    if( get_packet(qv, &pkt) == 0 )
116 
        return 0;
 116 
        return 0;
117 
 
 117 
 
118 
/*
 118 
/*
119 
    current_clock = -90.0 + get_master_clock();
 119 
    current_clock = -90.0 + get_master_clock();
120 
 
 120 
 
121 
    if( pkt.dts == AV_NOPTS_VALUE &&
 121 
    if( pkt.dts == AV_NOPTS_VALUE &&
122 
        Frame->reordered_opaque != AV_NOPTS_VALUE)
 122 
        Frame->reordered_opaque != AV_NOPTS_VALUE)
123 
        pts = Frame->reordered_opaque;
 123 
        pts = Frame->reordered_opaque;
124 
    else if(pkt.dts != AV_NOPTS_VALUE)
 124 
    else if(pkt.dts != AV_NOPTS_VALUE)
125 
        pts= pkt.dts;
 125 
        pts= pkt.dts;
126 
    else
 126 
    else
127 
        pts= 0;
 127 
        pts= 0;
128 
 
 128 
 
129 
 
 129 
 
130 
    pts *= av_q2d(video_time_base)*1000.0;
 130 
    pts *= av_q2d(video_time_base)*1000.0;
131 
*/
 131 
*/
132 
    if( 1 /*pts > current_clock*/)
 132 
    if( 1 /*pts > current_clock*/)
133 
    {
 133 
    {
134 
        frameFinished = 0;
 134 
        frameFinished = 0;
135 
 
 135 
 
136 
        ctx->reordered_opaque = pkt.pts;
 136 
        ctx->reordered_opaque = pkt.pts;
137 
 
 137 
 
138 
        if(avcodec_decode_video2(ctx, Frame, &frameFinished, &pkt) <= 0)
 138 
        if(avcodec_decode_video2(ctx, Frame, &frameFinished, &pkt) <= 0)
139 
            printf("video decoder error\n");
 139 
            printf("video decoder error\n");
140 
 
 140 
 
141 
        if(frameFinished)
 141 
        if(frameFinished)
142 
        {
 142 
        {
143 
            AVPicture *dst_pic;
 143 
            AVPicture *dst_pic;
144 
 
 144 
 
145 
            if( pkt.dts == AV_NOPTS_VALUE &&
 145 
            if( pkt.dts == AV_NOPTS_VALUE &&
146 
                Frame->reordered_opaque != AV_NOPTS_VALUE)
 146 
                Frame->reordered_opaque != AV_NOPTS_VALUE)
147 
                pts = Frame->reordered_opaque;
 147 
                pts = Frame->reordered_opaque;
148 
            else if(pkt.dts != AV_NOPTS_VALUE)
 148 
            else if(pkt.dts != AV_NOPTS_VALUE)
149 
                pts= pkt.dts;
 149 
                pts= pkt.dts;
150 
            else
 150 
            else
151 
                pts= 0;
 151 
                pts= 0;
152 
 
 152 
 
153 
//        pts = *(int64_t*)av_opt_ptr(avcodec_get_frame_class(),
 153 
//        pts = *(int64_t*)av_opt_ptr(avcodec_get_frame_class(),
154 
//                                Frame, "best_effort_timestamp");
 154 
//                                Frame, "best_effort_timestamp");
155 
 
 155 
 
156 
//        if (pts == AV_NOPTS_VALUE)
 156 
//        if (pts == AV_NOPTS_VALUE)
157 
//            pts = 0;
 157 
//            pts = 0;
158 
 
 158 
 
159 
            pts *= av_q2d(video_time_base);
 159 
            pts *= av_q2d(video_time_base);
160 
 
 160 
 
161 
            dst_pic = &frames[dfx].picture;
 161 
            dst_pic = &frames[dfx].picture;
162 
 
 162 
 
163 
            av_image_copy(dst_pic->data, dst_pic->linesize,
 163 
            av_image_copy(dst_pic->data, dst_pic->linesize,
164 
                      (const uint8_t**)Frame->data,
 164 
                      (const uint8_t**)Frame->data,
165 
                      Frame->linesize, ctx->pix_fmt, ctx->width, ctx->height);
 165 
                      Frame->linesize, ctx->pix_fmt, ctx->width, ctx->height);
166 
 
 166 
 
167 
            frames[dfx].pts = pts*1000.0;
 167 
            frames[dfx].pts = pts*1000.0;
168 
//            printf("pts %f\n", frames[dfx].pts);
 168 
//            printf("pts %f\n", frames[dfx].pts);
169 
 
 169 
 
170 
            frames[dfx].ready = 1;
 170 
            frames[dfx].ready = 1;
171 
 
 171 
 
172 
            dfx++;
 172 
            dfx++;
173 
            dfx&= 3;
 173 
            dfx&= 3;
174 
            frames_count++;
 174 
            frames_count++;
175 
        };
 175 
        };
176 
    };
 176 
    };
177 
    av_free_packet(&pkt);
 177 
    av_free_packet(&pkt);
178 
 
 178 
 
179 
    return 1;
 179 
    return 1;
180 
}
 180 
}
181 
 
 181 
 
182 
extern volatile enum player_state player_state;
 182 
extern volatile enum player_state player_state;
183 
extern volatile enum player_state decoder_state;
 183 
extern volatile enum player_state decoder_state;
184 
extern volatile enum player_state sound_state;
 184 
extern volatile enum player_state sound_state;
185 
 
 185 
 
186 
//rect_t     win_rect;
 - 
 
187 
 
 - 
 
188 
extern int64_t rewind_pos;
 186 
extern int64_t rewind_pos;
189 
 
 187 
 
190 
static void player_stop()
 188 
static void player_stop()
191 
{
 189 
{
192 
    window_t  *win;
 190 
    window_t  *win;
193 
 
 191 
 
194 
    win = main_render->win;
 192 
    win = main_render->win;
195 
 
 193 
 
196 
    rewind_pos = 0;
 194 
    rewind_pos = 0;
197 
 
 195 
 
198 
    win->panel.play_btn->img_default    = res_play_btn;
 196 
    win->panel.play_btn->img_default    = res_play_btn;
199 
    win->panel.play_btn->img_hilite     = res_play_btn;
 197 
    win->panel.play_btn->img_hilite     = res_play_btn;
200 
    win->panel.play_btn->img_pressed    = res_play_btn_pressed;
 198 
    win->panel.play_btn->img_pressed    = res_play_btn_pressed;
201 
    win->panel.prg->current             = rewind_pos;
 199 
    win->panel.prg->current             = rewind_pos;
202 
 
 200 
 
203 
    send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
 201 
    send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
204 
    player_state = STOP;
 202 
    player_state = STOP;
205 
    decoder_state = PLAY_2_STOP;
 203 
    decoder_state = PLAY_2_STOP;
206 
    sound_state = PLAY_2_STOP;
 204 
    sound_state = PLAY_2_STOP;
207 
    render_draw_client(main_render);
 205 
    render_draw_client(main_render);
208 
//    printf("stop player\n");
 206 
//    printf("stop player\n");
209 
 
 207 
 
210 
};
 208 
};
211 
 
 209 
 
212 
int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
 210 
int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
213 
{
 211 
{
214 
    window_t  *win = (window_t*)ctrl;
 212 
    window_t  *win = (window_t*)ctrl;
215 
    static int spc_down = 0;
 213 
    static int spc_down = 0;
216 
    static int ent_down = 0;
 214 
    static int ent_down = 0;
217 
 
 215 
 
218 
    switch(msg)
 216 
    switch(msg)
219 
    {
 217 
    {
220 
        case MSG_SIZE:
 218 
        case MSG_SIZE:
221 
            //printf("MSG_SIZE\n");
 219 
            if(main_render)
222 
            if(main_render)
 - 
 
223 
            {
 220 
            {
224 
                render_adjust_size(main_render, win);
 221 
                render_adjust_size(main_render, win);
225 
                render_draw_client(main_render);
 222 
                render_draw_client(main_render);
226 
            };
 223 
            };
227 
            break;
 224 
            break;
228 
 
 225 
 
229 
        case MSG_KEY:
 226 
        case MSG_KEY:
230 
            switch((short)arg2)
 227 
            switch((short)arg2)
231 
            {
 228 
            {
232 
                case 0x39:
 229 
                case 0x39:
233 
                    if(spc_down == 0)
 230 
                    if(spc_down == 0)
234 
                    {
 231 
                    {
235 
                        spc_down = 1;
 232 
                        spc_down = 1;
236 
                        send_message(win, MSG_LBTNDOWN, 0, 0);
 233 
                        send_message(win, MSG_LBTNDOWN, 0, 0);
237 
                    }
 234 
                    }
238 
                    break;
 235 
                    break;
239 
 
 236 
 
240 
                case 0xB9:
 237 
                case 0xB9:
241 
                    spc_down = 0;
 238 
                    spc_down = 0;
242 
                    break;
 239 
                    break;
243 
 
 240 
 
244 
                case 0x1C:
 241 
                case 0x1C:
245 
                    if(ent_down == 0)
 242 
                    if(ent_down == 0)
246 
                    {
 243 
                    {
247 
                        int screensize;
 244 
                        int screensize;
248 
                        if(win->win_state == NORMAL)
 245 
                        if(win->win_state == NORMAL)
249 
                        {
 246 
                        {
250 
                            win->saved = win->rc;
 247 
                            win->saved = win->rc;
251 
                            win->saved_state = win->win_state;
 248 
                            win->saved_state = win->win_state;
252 
 
 249 
 
253 
                            screensize = GetScreenSize();
 250 
                            screensize = GetScreenSize();
254 
                            __asm__ __volatile__(
 251 
                            __asm__ __volatile__(
255 
                            "int $0x40"
 252 
                            "int $0x40"
256 
                            ::"a"(67), "b"(0), "c"(0),
 253 
                            ::"a"(67), "b"(0), "c"(0),
257 
                            "d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );
 254 
                            "d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );
258 
                            win->win_state = FULLSCREEN;
 255 
                            win->win_state = FULLSCREEN;
259 
                            window_update_layout(win);
 256 
                            window_update_layout(win);
260 
                        }
 257 
                        }
261 
                        else if(win->win_state == FULLSCREEN)
 258 
                        else if(win->win_state == FULLSCREEN)
262 
                        {
 259 
                        {
263 
                            __asm__ __volatile__(
 260 
                            __asm__ __volatile__(
264 
                            "int $0x40"
 261 
                            "int $0x40"
265 
                            ::"a"(67), "b"(win->saved.l), "c"(win->saved.t),
 262 
                            ::"a"(67), "b"(win->saved.l), "c"(win->saved.t),
266 
                            "d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));
 263 
                            "d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));
267 
                            win->win_state = win->saved_state;
 264 
                            win->win_state = win->saved_state;
268 
                            window_update_layout(win);
 265 
                            window_update_layout(win);
269 
//                            if(win->saved_state == MAXIMIZED)
 266 
//                            if(win->saved_state == MAXIMIZED)
270 
                            {
 267 
//                            {
271 
                                blit_caption(&win->caption);
 268 
//                                blit_caption(&win->caption);
272 
                                blit_panel(&win->panel);
 269 
//                                blit_panel(&win->panel);
273 
                            }
 270 
//                            }
274 
                        }
 271 
                        }
275 
                        ent_down = 1;
 272 
                        ent_down = 1;
276 
                    };
 273 
                    };
277 
                    break;
 274 
                    break;
278 
 
 275 
 
279 
                case 0x9C:
 276 
                case 0x9C:
280 
                    ent_down = 0;
 277 
                    ent_down = 0;
281 
                    break;
 278 
                    break;
282 
            };
 279 
            };
283 
 
 280 
 
284 
        case MSG_DRAW_CLIENT:
 281 
        case MSG_DRAW_CLIENT:
285 
            if(main_render)
 282 
            if(main_render)
286 
            {
 283 
            {
287 
                render_draw_client(main_render);
 284 
                render_draw_client(main_render);
288 
            };
 285 
            };
289 
            break;
 286 
            break;
290 
 
 287 
 
291 
        case MSG_LBTNDOWN:
 288 
        case MSG_LBTNDOWN:
292 
 
 289 
 
293 
            if(player_state == PAUSE)
 290 
            if(player_state == PAUSE)
294 
            {
 291 
            {
295 
                win->panel.play_btn->img_default = res_pause_btn;
 292 
                win->panel.play_btn->img_default = res_pause_btn;
296 
                win->panel.play_btn->img_hilite  = res_pause_btn;
 293 
                win->panel.play_btn->img_hilite  = res_pause_btn;
297 
                win->panel.play_btn->img_pressed = res_pause_btn_pressed;
 294 
                win->panel.play_btn->img_pressed = res_pause_btn_pressed;
298 
                send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
 295 
                send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
299 
                player_state = PLAY;
 296 
                player_state = PLAY;
300 
                sound_state  = PAUSE_2_PLAY;
 297 
                sound_state  = PAUSE_2_PLAY;
301 
 
 298 
 
302 
            }
 299 
            }
303 
            else if(player_state == PLAY)
 300 
            else if(player_state == PLAY)
304 
            {
 301 
            {
305 
                win->panel.play_btn->img_default = res_play_btn;
 302 
                win->panel.play_btn->img_default = res_play_btn;
306 
                win->panel.play_btn->img_hilite  = res_play_btn;
 303 
                win->panel.play_btn->img_hilite  = res_play_btn;
307 
                win->panel.play_btn->img_pressed = res_play_btn_pressed;
 304 
                win->panel.play_btn->img_pressed = res_play_btn_pressed;
308 
                send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
 305 
                send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
309 
                player_state = PAUSE;
 306 
                player_state = PAUSE;
310 
                sound_state  = PLAY_2_PAUSE;
 307 
                sound_state  = PLAY_2_PAUSE;
311 
            }
 308 
            }
312 
            break;
 309 
            break;
313 
 
 310 
 
314 
        case MSG_COMMAND:
 311 
        case MSG_COMMAND:
315 
            switch((short)arg1)
 312 
            switch((short)arg1)
316 
            {
 313 
            {
317 
                case ID_PLAY:
 314 
                case ID_PLAY:
318 
                    if(player_state == PAUSE)
 315 
                    if(player_state == PAUSE)
319 
                    {
 316 
                    {
320 
                        win->panel.play_btn->img_default  = res_pause_btn;
 317 
                        win->panel.play_btn->img_default  = res_pause_btn;
321 
                        win->panel.play_btn->img_hilite   = res_pause_btn;
 318 
                        win->panel.play_btn->img_hilite   = res_pause_btn;
322 
                        win->panel.play_btn->img_pressed = res_pause_btn_pressed;
 319 
                        win->panel.play_btn->img_pressed = res_pause_btn_pressed;
323 
                        player_state = PLAY;
 320 
                        player_state = PLAY;
324 
                        sound_state = PAUSE_2_PLAY;
 321 
                        sound_state = PAUSE_2_PLAY;
325 
                    }
 322 
                    }
326 
                    else if(player_state == PLAY)
 323 
                    else if(player_state == PLAY)
327 
                    {
 324 
                    {
328 
                        win->panel.play_btn->img_default = res_play_btn;
 325 
                        win->panel.play_btn->img_default = res_play_btn;
329 
                        win->panel.play_btn->img_hilite  = res_play_btn;
 326 
                        win->panel.play_btn->img_hilite  = res_play_btn;
330 
                        win->panel.play_btn->img_pressed  = res_play_btn_pressed;
 327 
                        win->panel.play_btn->img_pressed  = res_play_btn_pressed;
331 
                        player_state = PAUSE;
 328 
                        player_state = PAUSE;
332 
                        sound_state  = PLAY_2_PAUSE;
 329 
                        sound_state  = PLAY_2_PAUSE;
333 
                    }
 330 
                    }
334 
                    else if(player_state == STOP)
 331 
                    else if(player_state == STOP)
335 
                    {
 332 
                    {
336 
                        win->panel.play_btn->img_default  = res_pause_btn;
 333 
                        win->panel.play_btn->img_default  = res_pause_btn;
337 
                        win->panel.play_btn->img_hilite   = res_pause_btn;
 334 
                        win->panel.play_btn->img_hilite   = res_pause_btn;
338 
                        win->panel.play_btn->img_pressed = res_pause_btn_pressed;
 335 
                        win->panel.play_btn->img_pressed = res_pause_btn_pressed;
339 
                        rewind_pos = 0;
 336 
                        rewind_pos = 0;
340 
                        send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
 337 
                        send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
341 
                        player_state = PLAY;
 338 
                        player_state = PLAY;
342 
                        decoder_state = PREPARE;
 339 
                        decoder_state = PREPARE;
343 
                    }
 340 
                    }
344 
                    break;
 341 
                    break;
345 
 
 342 
 
346 
                case ID_STOP:
 343 
                case ID_STOP:
347 
                    player_stop();
 344 
                    player_stop();
348 
                    break;
 345 
                    break;
349 
 
 346 
 
350 
                case ID_PROGRESS:
 347 
                case ID_PROGRESS:
351 
                    if(player_state != REWIND)
 348 
                    if(player_state != REWIND)
352 
                    {
 349 
                    {
353 
                        progress_t *prg = (progress_t*)arg2;
 350 
                        progress_t *prg = (progress_t*)arg2;
354 
 
 351 
 
355 
                        rewind_pos = (prg->max - prg->min)*prg->pos/prg->ctrl.w;
 352 
                        rewind_pos = (prg->max - prg->min)*prg->pos/prg->ctrl.w;
356 
 
 353 
 
357 
//                        printf("progress action pos: %d time: %f\n", prg->pos, (double)rewind_pos);
 354 
//                        printf("progress action pos: %d time: %f\n", prg->pos, (double)rewind_pos);
358 
                        player_state  = REWIND;
 355 
                        player_state  = REWIND;
359 
                        decoder_state = REWIND;
 356 
                        decoder_state = REWIND;
360 
                        sound_state   = PLAY_2_STOP;
 357 
                        sound_state   = PLAY_2_STOP;
361 
                        if(rewind_pos < prg->current)
 358 
                        if(rewind_pos < prg->current)
362 
                        {
 359 
                        {
363 
                            prg->current  = rewind_pos;
 360 
                            prg->current  = rewind_pos;
364 
                            rewind_pos = -rewind_pos;
 361 
                            rewind_pos = -rewind_pos;
365 
                        }
 362 
                        }
366 
                        else
 363 
                        else
367 
                            prg->current  = rewind_pos;
 364 
                            prg->current  = rewind_pos;
368 
 
 365 
 
369 
                        win->panel.play_btn->img_default  = res_pause_btn;
 366 
                        win->panel.play_btn->img_default  = res_pause_btn;
370 
                        win->panel.play_btn->img_hilite   = res_pause_btn;
 367 
                        win->panel.play_btn->img_hilite   = res_pause_btn;
371 
                        win->panel.play_btn->img_pressed  = res_pause_btn_pressed;
 368 
                        win->panel.play_btn->img_pressed  = res_pause_btn_pressed;
372 
                        send_message(&prg->ctrl, MSG_PAINT, 0, 0);
 369 
                        send_message(&prg->ctrl, MSG_PAINT, 0, 0);
373 
                    };
 370 
                    };
374 
                    break;
 371 
                    break;
375 
 
 372 
 
376 
                case ID_VOL_CTRL:
 373 
                case ID_VOL_CTRL:
377 
                {
 374 
                {
378 
                    slider_t *sld = (slider_t*)arg2;
 375 
                    slider_t *sld = (slider_t*)arg2;
379 
                    int      peak;
 376 
                    int      peak;
380 
                    int      level;
 377 
                    int      level;
381 
 
 378 
 
382 
                    peak = sld->min + sld->pos * (sld->max - sld->min)/(96);
 379 
                    peak = sld->min + sld->pos * (sld->max - sld->min)/(96);
383 
//                    level = (log2(peak+16384)*10000.0)/15 - 10000;
 380 
//                    level = (log2(peak+16384)*10000.0)/15 - 10000;
384 
                    level =  peak;
 381 
                    level =  peak;
385 
 
 382 
 
386 
//                    printf("level %d\n", level);
 383 
//                    printf("level %d\n", level);
387 
                    set_audio_volume(level, level);
 384 
                    set_audio_volume(level, level);
388 
                    send_message(&sld->ctrl, MSG_PAINT, 0, 0);
 385 
                    send_message(&sld->ctrl, MSG_PAINT, 0, 0);
389 
                    win->panel.lvl->vol = level;
 386 
                    win->panel.lvl->vol = level;
390 
                }
 387 
                }
391 
 
 388 
 
392 
                default:
 389 
                default:
393 
                    break;
 390 
                    break;
394 
            }
 391 
            }
395 
            break;
 392 
            break;
396 
 
 393 
 
397 
        default:
 394 
        default:
398 
            def_window_proc(ctrl,msg,arg1,arg2);
 395 
            def_window_proc(ctrl,msg,arg1,arg2);
399 
    };
 396 
    };
400 
    return 0;
 397 
    return 0;
401 
};
 398 
};
402 
 
 399 
 
403 
#define VERSION_A     1
 400 
#define VERSION_A     1
404 
 
 401 
 
405 
extern queue_t  q_video;
 402 
extern queue_t  q_video;
406 
extern queue_t  q_audio;
 403 
extern queue_t  q_audio;
407 
 
 404 
 
408 
void render_time(render_t *render)
 405 
void render_time(render_t *render)
409 
{
 406 
{
410 
    progress_t  *prg = main_render->win->panel.prg;
 407 
    progress_t  *prg = main_render->win->panel.prg;
411 
    level_t     *lvl = main_render->win->panel.lvl;
 408 
    level_t     *lvl = main_render->win->panel.lvl;
412 
 
 409 
 
413 
    double      ctime;            /*    milliseconds    */
 410 
    double      ctime;            /*    milliseconds    */
414 
    double      fdelay;           /*    milliseconds    */
 411 
    double      fdelay;           /*    milliseconds    */
415 
 
 412 
 
416 
//again:
 413 
//again:
417 
 
 414 
 
418 
    if(player_state == CLOSED)
 415 
    if(player_state == CLOSED)
419 
    {
 416 
    {
420 
        render->win->win_command = WIN_CLOSED;
 417 
        render->win->win_command = WIN_CLOSED;
421 
        return;
 418 
        return;
422 
    }
 419 
    }
423 
    else if((player_state == PAUSE) || (player_state == REWIND))
 420 
    else if((player_state == PAUSE) || (player_state == REWIND))
424 
    {
 421 
    {
425 
        delay(1);
 422 
        delay(1);
426 
        return;
 423 
        return;
427 
    }
 424 
    }
428 
    else if (decoder_state == STOP && frames_count  == 0 &&
 425 
    else if (decoder_state == STOP && frames_count  == 0 &&
429 
              player_state  != STOP)
 426 
              player_state  != STOP)
430 
    {
 427 
    {
431 
        player_stop();
 428 
        player_stop();
432 
    }
 429 
    }
433 
    else if(player_state != PLAY)
 430 
    else if(player_state != PLAY)
434 
    {
 431 
    {
435 
        delay(1);
 432 
        delay(1);
436 
        return;
 433 
        return;
437 
    };
 434 
    };
438 
 
 435 
 
439 
 
 436 
 
440 
#ifdef VERSION_A
 437 
#ifdef VERSION_A
441 
    if(frames[vfx].ready == 1 )
 438 
    if(frames[vfx].ready == 1 )
442 
    {
 439 
    {
443 
        int sys_time;
 440 
        int sys_time;
444 
 
 441 
 
445 
        ctime = get_master_clock();
 442 
        ctime = get_master_clock();
446 
        fdelay = (frames[vfx].pts - ctime);
 443 
        fdelay = (frames[vfx].pts - ctime);
447 
 
 444 
 
448 
//        printf("pts %f time %f delay %f\n",
 445 
//        printf("pts %f time %f delay %f\n",
449 
//                frames[vfx].pts, ctime, fdelay);
 446 
//                frames[vfx].pts, ctime, fdelay);
450 
 
 447 
 
451 
        if(fdelay > 15.0)
 448 
        if(fdelay > 15.0)
452 
        {
 449 
        {
453 
            delay((int)fdelay/10);
 450 
            delay((int)fdelay/10);
454 
        //    return;
 451 
        //    return;
455 
        };
 452 
        };
456 
#if 0
 453 
#if 0
457 
        ctime = get_master_clock();
 454 
        ctime = get_master_clock();
458 
        fdelay = (frames[vfx].pts - ctime);
 455 
        fdelay = (frames[vfx].pts - ctime);
459 
 
 456 
 
460 
//        while(fdelay > 0)
 457 
//        while(fdelay > 0)
461 
//        {
 458 
//        {
462 
//            yield();
 459 
//            yield();
463 
//            ctime = get_master_clock();
 460 
//            ctime = get_master_clock();
464 
//            fdelay = (frames[vfx].pts - ctime);
 461 
//            fdelay = (frames[vfx].pts - ctime);
465 
//        }
 462 
//        }
466 
 
 463 
 
467 
//        sys_time = get_tick_count();
 464 
//        sys_time = get_tick_count();
468 
 
 465 
 
469 
//        if(fdelay < 0)
 466 
//        if(fdelay < 0)
470 
//            printf("systime %d pts %f time %f delay %f\n",
 467 
//            printf("systime %d pts %f time %f delay %f\n",
471 
//                    sys_time*10, frames[vfx].pts, ctime, fdelay);
 468 
//                    sys_time*10, frames[vfx].pts, ctime, fdelay);
472 
 
 469 
 
473 
        printf("pts %f time %f delay %f\n",
 470 
        printf("pts %f time %f delay %f\n",
474 
                frames[vfx].pts, ctime, fdelay);
 471 
                frames[vfx].pts, ctime, fdelay);
475 
        printf("video cache %d audio cache %d\n", q_video.size/1024, q_audio.size/1024);
 472 
        printf("video cache %d audio cache %d\n", q_video.size/1024, q_audio.size/1024);
476 
#endif
 473 
#endif
477 
 
 474 
 
478 
        main_render->draw(main_render, &frames[vfx].picture);
 475 
        main_render->draw(main_render, &frames[vfx].picture);
479 
        if(main_render->win->win_state != FULLSCREEN)
 476 
        if(main_render->win->win_state != FULLSCREEN)
480 
        {
 477 
        {
481 
            prg->current = frames[vfx].pts*1000;
 478 
            prg->current = frames[vfx].pts*1000;
482 
//        printf("current %f\n", prg->current);
 479 
//        printf("current %f\n", prg->current);
483 
            lvl->current = vfx & 1 ? sound_level_1 : sound_level_0;
 480 
            lvl->current = vfx & 1 ? sound_level_1 : sound_level_0;
484 
 
 481 
 
485 
            send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);
 482 
            send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);
486 
 
 483 
 
487 
            if(main_render->win->panel.layout)
 484 
            if(main_render->win->panel.layout)
488 
                send_message(&lvl->ctrl, MSG_PAINT, 0, 0);
 485 
                send_message(&lvl->ctrl, MSG_PAINT, 0, 0);
489 
        }
 486 
        }
490 
 
 487 
 
491 
        frames_count--;
 488 
        frames_count--;
492 
        frames[vfx].ready = 0;
 489 
        frames[vfx].ready = 0;
493 
        vfx++;
 490 
        vfx++;
494 
        vfx&= 3;
 491 
        vfx&= 3;
495 
    }
 492 
    }
496 
    else delay(1);
 493 
    else delay(1);
497 
 
 494 
 
498 
#else
 495 
#else
499 
 
 496 
 
500 
    if(frames[vfx].ready == 1 )
 497 
    if(frames[vfx].ready == 1 )
501 
    {
 498 
    {
502 
        ctime = get_master_clock();
 499 
        ctime = get_master_clock();
503 
        fdelay = (frames[vfx].pts - ctime);
 500 
        fdelay = (frames[vfx].pts - ctime);
504 
 
 501 
 
505 
//            printf("pts %f time %f delay %f\n",
 502 
//            printf("pts %f time %f delay %f\n",
506 
//                    frames[vfx].pts, ctime, fdelay);
 503 
//                    frames[vfx].pts, ctime, fdelay);
507 
 
 504 
 
508 
        if(fdelay < 0.0 )
 505 
        if(fdelay < 0.0 )
509 
        {
 506 
        {
510 
            int  next_vfx;
 507 
            int  next_vfx;
511 
            fdelay = 0;
 508 
            fdelay = 0;
512 
            next_vfx = (vfx+1) & 3;
 509 
            next_vfx = (vfx+1) & 3;
513 
            if( frames[next_vfx].ready == 1 )
 510 
            if( frames[next_vfx].ready == 1 )
514 
            {
 511 
            {
515 
                if(frames[next_vfx].pts <= ctime)
 512 
                if(frames[next_vfx].pts <= ctime)
516 
                {
 513 
                {
517 
                    frames[vfx].ready = 0;                  // skip this frame
 514 
                    frames[vfx].ready = 0;                  // skip this frame
518 
                    vfx++;
 515 
                    vfx++;
519 
                    vfx&= 3;
 516 
                    vfx&= 3;
520 
                }
 517 
                }
521 
                else
 518 
                else
522 
                {
 519 
                {
523 
                    if( (frames[next_vfx].pts - ctime) <
 520 
                    if( (frames[next_vfx].pts - ctime) <
524 
                        ( ctime - frames[vfx].pts) )
 521 
                        ( ctime - frames[vfx].pts) )
525 
                    {
 522 
                    {
526 
                        frames[vfx].ready = 0;                  // skip this frame
 523 
                        frames[vfx].ready = 0;                  // skip this frame
527 
                        vfx++;
 524 
                        vfx++;
528 
                        vfx&= 3;
 525 
                        vfx&= 3;
529 
                        fdelay = (frames[next_vfx].pts - ctime);
 526 
                        fdelay = (frames[next_vfx].pts - ctime);
530 
                    }
 527 
                    }
531 
                }
 528 
                }
532 
            };
 529 
            };
533 
        };
 530 
        };
534 
 
 531 
 
535 
        if(fdelay > 10.0)
 532 
        if(fdelay > 10.0)
536 
        {
 533 
        {
537 
           int val = fdelay;
 534 
           int val = fdelay;
538 
           printf("pts %f time %f delay %d\n",
 535 
           printf("pts %f time %f delay %d\n",
539 
                   frames[vfx].pts, ctime, val);
 536 
                   frames[vfx].pts, ctime, val);
540 
           delay(val/10);
 537 
           delay(val/10);
541 
        };
 538 
        };
542 
 
 539 
 
543 
        ctime = get_master_clock();
 540 
        ctime = get_master_clock();
544 
        fdelay = (frames[vfx].pts - ctime);
 541 
        fdelay = (frames[vfx].pts - ctime);
545 
 
 542 
 
546 
        printf("pts %f time %f delay %f\n",
 543 
        printf("pts %f time %f delay %f\n",
547 
                frames[vfx].pts, ctime, fdelay);
 544 
                frames[vfx].pts, ctime, fdelay);
548 
 
 545 
 
549 
        main_render->draw(main_render, &frames[vfx].picture);
 546 
        main_render->draw(main_render, &frames[vfx].picture);
550 
        main_render->win->panel.prg->current = frames[vfx].pts;
 547 
        main_render->win->panel.prg->current = frames[vfx].pts;
551 
//        send_message(&render->win->panel.prg->ctrl, MSG_PAINT, 0, 0);
 548 
//        send_message(&render->win->panel.prg->ctrl, MSG_PAINT, 0, 0);
552 
        frames[vfx].ready = 0;
 549 
        frames[vfx].ready = 0;
553 
        vfx++;
 550 
        vfx++;
554 
        vfx&= 3;
 551 
        vfx&= 3;
555 
    }
 552 
    }
556 
    else yield();
 553 
    else yield();
557 
#endif
 554 
#endif
558 
 
 555 
 
559 
}
 556 
}
560 
 
 557 
 
561 
 
 558 
 
562 
extern char *movie_file;
 559 
extern char *movie_file;
563 
 
 560 
 
564 
int video_thread(void *param)
 561 
int video_thread(void *param)
565 
{
 562 
{
566 
    AVCodecContext *ctx = param;
 563 
    AVCodecContext *ctx = param;
567 
    window_t  *MainWindow;
 564 
    window_t  *MainWindow;
568 
 
 565 
 
- 
 
 566 
 
- 
 
 567 
    printf("%s\n", __FUNCTION__);
- 
 
 568 
 
569 
    init_winlib();
 569 
    init_winlib();
570 
 
 570 
 
571 
    MainWindow = create_window(movie_file,0,
 571 
    MainWindow = create_window(movie_file,0,
572 
                               10,10,width,height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
 572 
                               10,10,width,height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
573 
 
 573 
 
574 
    MainWindow->panel.prg->max = stream_duration;
 574 
    MainWindow->panel.prg->max = stream_duration;
575 
//    printf("MainWindow %x\n", MainWindow);
 575 
//    printf("MainWindow %x\n", MainWindow);
576 
 
 576 
 
577 
    show_window(MainWindow, NORMAL);
 577 
    show_window(MainWindow, NORMAL);
578 
 
 578 
 
579 
//    __asm__ __volatile__("int3");
 579 
//    __asm__ __volatile__("int3");
580 
 
 580 
 
581 
    main_render = create_render(MainWindow, ctx, HW_TEX_BLIT|HW_BIT_BLIT);
 581 
    main_render = create_render(MainWindow, ctx, HW_TEX_BLIT|HW_BIT_BLIT);
582 
    if( main_render == NULL)
 582 
    if( main_render == NULL)
583 
    {
 583 
    {
584 
        printf("Cannot create render\n\r");
 584 
        printf("Cannot create render\n\r");
585 
        return 0;
 585 
        return 0;
586 
    };
 586 
    };
587 
 
 587 
 
588 
    render_draw_client(main_render);
 588 
    render_draw_client(main_render);
589 
    player_state = PLAY;
 589 
    player_state = PLAY;
590 
 
 590 
 
591 
    run_render(MainWindow, main_render);
 591 
    run_render(MainWindow, main_render);
592 
 
 592 
 
593 
    destroy_render(main_render);
 593 
    destroy_render(main_render);
594 
    fini_winlib();
 594 
    fini_winlib();
595 
 
 595 
 
596 
    player_state = CLOSED;
 596 
    player_state = CLOSED;
597 
    return 0;
 597 
    return 0;
598 
};
 598 
};
599 
 
 599 
 
600 
 
 600 
 
601 
void draw_hw_picture(render_t *render, AVPicture *picture);
 601 
void draw_hw_picture(render_t *render, AVPicture *picture);
602 
void draw_sw_picture(render_t *render, AVPicture *picture);
 602 
void draw_sw_picture(render_t *render, AVPicture *picture);
603 
 
 603 
 
604 
render_t *create_render(window_t *win, AVCodecContext *ctx, uint32_t flags)
 604 
render_t *create_render(window_t *win, AVCodecContext *ctx, uint32_t flags)
605 
{
 605 
{
606 
    render_t *render;
 606 
    render_t *render;
607 
 
 607 
 
608 
    uint32_t right, bottom, draw_w, draw_h;
 608 
    uint32_t right, bottom, draw_w, draw_h;
609 
    uint32_t s, sw, sh;
 609 
    uint32_t s, sw, sh;
610 
    uint8_t  state;
 610 
    uint8_t  state;
611 
 
 611 
 
612 
//    __asm__ __volatile__("int3");
 612 
//    __asm__ __volatile__("int3");
613 
 
 613 
 
614 
    render = (render_t*)malloc(sizeof(render_t));
 614 
    render = (render_t*)malloc(sizeof(render_t));
615 
    memset(render, 0, sizeof(render_t));
 615 
    memset(render, 0, sizeof(render_t));
616 
 
 616 
 
617 
    render->win = win;
 617 
    render->win = win;
618 
 
 618 
 
619 
    render->ctx_width  = ctx->width;
 619 
    render->ctx_width  = ctx->width;
620 
    render->ctx_height = ctx->height;
 620 
    render->ctx_height = ctx->height;
621 
    render->ctx_format = ctx->pix_fmt;
 621 
    render->ctx_format = ctx->pix_fmt;
622 
 
 622 
 
623 
    mutex_lock(&driver_lock);
 623 
    mutex_lock(&driver_lock);
624 
    render->caps = init_pixlib(flags);
 624 
    render->caps = pxInit(1);
625 
    mutex_unlock(&driver_lock);
 625 
    mutex_unlock(&driver_lock);
626 
 
 626 
 
627 
    right  = win->w;
 627 
    right  = win->w;
628 
    bottom = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
 628 
    bottom = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
629 
 
 629 
 
630 
 //   printf("window width %d height %d\n",
 630 
    printf("window width %d height %d\n",
631 
 //                   right, bottom);
 631 
                    right, bottom);
632 
 
 632 
 
633 
    render->win_state  = win->win_state;
 633 
    render->win_state  = win->win_state;
634 
 
 634 
 
635 
    draw_w = bottom*render->ctx_width/render->ctx_height;
 635 
    draw_w = bottom*render->ctx_width/render->ctx_height;
636 
    draw_h = right*render->ctx_height/render->ctx_width;
 636 
    draw_h = right*render->ctx_height/render->ctx_width;
637 
 
 637 
 
638 
    if(draw_w > right)
 638 
    if(draw_w > right)
639 
    {
 639 
    {
640 
        draw_w = right;
 640 
        draw_w = right;
641 
        draw_h = right*render->ctx_height/render->ctx_width;
 641 
        draw_h = right*render->ctx_height/render->ctx_width;
642 
    };
 642 
    };
643 
 
 643 
 
644 
    if(draw_h > bottom)
 644 
    if(draw_h > bottom)
645 
    {
 645 
    {
646 
        draw_h = bottom;
 646 
        draw_h = bottom;
647 
        draw_w = bottom*render->ctx_width/render->ctx_height;
 647 
        draw_w = bottom*render->ctx_width/render->ctx_height;
648 
    };
 648 
    };
649 
 
 649 
 
650 
    render->win_width  = win->w;
 650 
    render->win_width  = win->w;
651 
    render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
 651 
    render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
652 
 
 652 
 
653 
    render_set_size(render, draw_w, draw_h);
 653 
    render_set_size(render, draw_w, draw_h);
654 
 
 654 
 
- 
 
 655 
    pxCreateClient(0, CAPTION_HEIGHT, right, bottom);
655 
 
 656 
 
656 
    if(render->caps==0)
 657 
    if(render->caps==0)
657 
    {
 658 
    {
658 
        render->bitmap[0].width  = draw_w;
 659 
        render->bitmap[0] = pxCreateBitmap(draw_w, draw_h);
659 
        render->bitmap[0].height = draw_h;
 660 
        if(render->bitmap[0] == NULL)
660 
 
 661 
        {
661 
        if( create_bitmap(&render->bitmap[0]) != 0 )
 - 
 
662 
        {
 - 
 
663 
            free(render);
 662 
            free(render);
664 
            return NULL;
 663 
            return NULL;
665 
        }
 664 
        }
666 
        render->draw = draw_sw_picture;
 665 
        render->draw = draw_sw_picture;
667 
    }
 666 
    }
668 
    else
 667 
    else
669 
    {
 668 
    {
670 
        int width, height, flags;
 669 
        int width, height;
671 
        int i;
 670 
        int i;
672 
 
 671 
 
673 
        if(render->caps & HW_TEX_BLIT)
 672 
        if(render->caps & HW_TEX_BLIT)
674 
        {
 673 
        {
675 
            sna_create_mask();
 674 
            width  = render->ctx_width;
676 
 
 - 
 
677 
            width  = render->ctx_width;
 - 
 
678 
            height = render->ctx_height;
 675 
            height = render->ctx_height;
679 
            flags  = HW_TEX_BLIT;
 676 
        }
680 
        }
 - 
 
681 
        else
 677 
        else
682 
        {
 678 
        {
683 
            width  = draw_w;
 679 
            width  = draw_w;
684 
            height = draw_h;;
 680 
            height = draw_h;;
685 
            flags  = HW_BIT_BLIT;
 681 
        }
686 
        }
 - 
 
687 
 
 682 
 
688 
        for( i=0; i < 2; i++)
 683 
        for( i=0; i < 2; i++)
689 
        {
 684 
        {
690 
            render->bitmap[i].width  = width;
 685 
            render->bitmap[i] = pxCreateBitmap(width, height);
691 
            render->bitmap[i].height = height;
 - 
 
692 
            render->bitmap[i].flags  = flags;
 686 
            if( render->bitmap[i] == NULL )
693 
 
 687 
            {
694 
            if( create_bitmap(&render->bitmap[i]) != 0 )
 - 
 
695 
            {
 - 
 
696 
                player_state = CLOSED;
 688 
                player_state = CLOSED;
697 
                free(render);
 689 
                free(render);
698 
                return NULL;
 690 
                return NULL;
699 
            };
 691 
            };
700 
        }
 692 
        }
701 
 
 693 
 
702 
        render->state = INIT;
 694 
        render->state = INIT;
703 
        render->target = 0;
 695 
        render->target = 0;
704 
        render->draw   = draw_hw_picture;
 696 
        render->draw   = draw_hw_picture;
705 
    };
 697 
    };
706 
 
 698 
 
707 
 
 - 
 
708 
    printf("FPlay %s render engine: context %dx%d picture %dx%d\n",
 699 
    printf("FPlay %s render engine: context %dx%d picture %dx%d\n",
709 
           render->caps & HW_TEX_BLIT ? "hw_tex_blit":
 700 
           render->caps & HW_TEX_BLIT ? "hw_tex_blit":
710 
           render->caps & HW_BIT_BLIT ? "hw_bit_blit":"software",
 701 
           render->caps & HW_BIT_BLIT ? "hw_bit_blit":"software",
711 
           render->ctx_width, render->ctx_height,
 702 
           render->ctx_width, render->ctx_height,
712 
           draw_w, draw_h);
 703 
           draw_w, draw_h);
713 
 
 704 
 
714 
//    if(init_hw_context(ctx) == 0)
 - 
 
715 
//        printf("create hardware decoder context\n");
 - 
 
716 
 
 - 
 
717 
    return render;
 705 
    return render;
718 
};
 706 
};
719 
 
 707 
 
720 
void destroy_render(render_t *render)
 708 
void destroy_render(render_t *render)
721 
{
 709 
{
722 
 
 710 
 
723 
    destroy_bitmap(&render->bitmap[0]);
 711 
    pxDestroyBitmap(render->bitmap[0]);
724 
 
 712 
 
725 
    if(render->caps & (HW_BIT_BLIT|HW_TEX_BLIT))          /* hw blitter */
 713 
    if(render->caps & (HW_BIT_BLIT|HW_TEX_BLIT))          /* hw blitter */
726 
        destroy_bitmap(&render->bitmap[1]);
 714 
        pxDestroyBitmap(render->bitmap[1]);
727 
 
 715 
 
728 
    done_pixlib();
 716 
    pxFini();
729 
};
 717 
};
730 
 
 718 
 
731 
void render_set_size(render_t *render, int width, int height)
 719 
void render_set_size(render_t *render, int width, int height)
732 
{
 720 
{
733 
    int i;
 721 
    int i;
734 
 
 722 
 
735 
    render->layout = 0;
 723 
    render->layout = 0;
736 
    render->rcvideo.l = 0;
 724 
    render->rcvideo.l = 0;
737 
    render->rcvideo.t = 0;
 725 
    render->rcvideo.t = 0;
738 
    render->rcvideo.r = width;
 726 
    render->rcvideo.r = width;
739 
    render->rcvideo.b = height;
 727 
    render->rcvideo.b = height;
740 
 
 728 
 
741 
//    printf("render width %d height %d\n",width, height);
 729 
//    printf("render width %d height %d\n",width, height);
742 
 
 730 
 
743 
    if( render->win_height > height )
 731 
    if( render->win_height > height )
744 
    {
 732 
    {
745 
        int yoffs;
 733 
        int yoffs;
746 
        yoffs = (render->win_height-height)/2;
 734 
        yoffs = (render->win_height-height)/2;
747 
        if(yoffs)
 735 
        if(yoffs)
748 
        {
 736 
        {
749 
            render->rctop.t = 0;
 737 
            render->rctop.t = 0;
750 
            render->rctop.b = yoffs;
 738 
            render->rctop.b = yoffs;
751 
            render->rcvideo.t  = yoffs;
 739 
            render->rcvideo.t  = yoffs;
752 
            render->layout |= HAS_TOP;
 740 
            render->layout |= HAS_TOP;
753 
        }
 741 
        }
754 
 
 742 
 
755 
        yoffs = render->win_height-(render->rcvideo.t+render->rcvideo.b);
 743 
        yoffs = render->win_height-(render->rcvideo.t+render->rcvideo.b);
756 
        if(yoffs)
 744 
        if(yoffs)
757 
        {
 745 
        {
758 
            render->rcbottom.t = render->rcvideo.t+render->rcvideo.b;
 746 
            render->rcbottom.t = render->rcvideo.t+render->rcvideo.b;
759 
            render->rcbottom.b = yoffs;
 747 
            render->rcbottom.b = yoffs;
760 
            render->layout |= HAS_BOTTOM;
 748 
            render->layout |= HAS_BOTTOM;
761 
        }
 749 
        }
762 
    }
 750 
    }
763 
 
 751 
 
764 
    if( render->win_width > width )
 752 
    if( render->win_width > width )
765 
    {
 753 
    {
766 
        int xoffs;
 754 
        int xoffs;
767 
        xoffs = (render->win_width-width)/2;
 755 
        xoffs = (render->win_width-width)/2;
768 
        if(xoffs)
 756 
        if(xoffs)
769 
        {
 757 
        {
770 
            render->rcleft.r  = xoffs;
 758 
            render->rcleft.r  = xoffs;
771 
            render->rcvideo.l = xoffs;
 759 
            render->rcvideo.l = xoffs;
772 
            render->layout |= HAS_LEFT;
 760 
            render->layout |= HAS_LEFT;
773 
        }
 761 
        }
774 
        xoffs = render->win_width-(render->rcvideo.l+render->rcvideo.r);
 762 
        xoffs = render->win_width-(render->rcvideo.l+render->rcvideo.r);
775 
        if(xoffs)
 763 
        if(xoffs)
776 
        {
 764 
        {
777 
            render->rcright.l = render->rcvideo.l+render->rcvideo.r;
 765 
            render->rcright.l = render->rcvideo.l+render->rcvideo.r;
778 
            render->rcright.r = xoffs;
 766 
            render->rcright.r = xoffs;
779 
            render->layout |= HAS_RIGHT;
 767 
            render->layout |= HAS_RIGHT;
780 
        }
 768 
        }
781 
    };
 769 
    };
782 
};
 770 
};
783 
 
 771 
 
784 
void render_adjust_size(render_t *render, window_t *win)
 772 
void render_adjust_size(render_t *render, window_t *win)
785 
{
 773 
{
786 
    uint32_t right, bottom, new_w, new_h;
 774 
    uint32_t right, bottom, new_w, new_h;
787 
    uint32_t s, sw, sh;
 775 
    uint32_t s, sw, sh;
788 
    uint8_t  state;
 776 
    uint8_t  state;
789 
 
 777 
 
790 
    right  = win->w;
 778 
    right  = win->w;
791 
    bottom = win->h;
 779 
    bottom = win->h;
792 
 
 780 
 
793 
    if(win->win_state != FULLSCREEN)
 781 
    if(win->win_state != FULLSCREEN)
794 
        bottom-= CAPTION_HEIGHT+PANEL_HEIGHT;
 782 
        bottom-= CAPTION_HEIGHT+PANEL_HEIGHT;
795 
 
 783 
 
796 
 //   printf("window width %d height %d\n",
 784 
 //   printf("window width %d height %d\n",
797 
 //                   right, bottom);
 785 
 //                   right, bottom);
798 
 
 786 
 
799 
    render->win_state  = win->win_state;
 787 
    render->win_state  = win->win_state;
800 
 
 788 
 
801 
    if(render->win_state == MINIMIZED)
 789 
    if(render->win_state == MINIMIZED)
802 
        return;
 790 
        return;
803 
 
 791 
 
804 
    if(render->win_state == ROLLED)
 792 
    if(render->win_state == ROLLED)
805 
        return;
 793 
        return;
806 
 
 794 
 
807 
    if( right  == render->win_width &&
 795 
    if( right  == render->win_width &&
808 
        bottom == render->win_height)
 796 
        bottom == render->win_height)
809 
        return;
 797 
        return;
810 
 
 798 
 
811 
//    printf("%s r: %d b: %d\n", __FUNCTION__, right, bottom);
 799 
//    printf("%s r: %d b: %d\n", __FUNCTION__, right, bottom);
812 
 
 800 
 
813 
    new_w = bottom*render->ctx_width/render->ctx_height;
 801 
    new_w = bottom*render->ctx_width/render->ctx_height;
814 
    new_h = right*render->ctx_height/render->ctx_width;
 802 
    new_h = right*render->ctx_height/render->ctx_width;
815 
 
 803 
 
816 
    if(new_w > right)
 804 
    if(new_w > right)
817 
    {
 805 
    {
818 
        new_w = right;
 806 
        new_w = right;
819 
        new_h = right*render->ctx_height/render->ctx_width;
 807 
        new_h = right*render->ctx_height/render->ctx_width;
820 
    };
 808 
    };
821 
    if(new_h > bottom)
 809 
    if(new_h > bottom)
822 
    {
 810 
    {
823 
        new_h = bottom;
 811 
        new_h = bottom;
824 
        new_w = bottom*render->ctx_width/render->ctx_height;
 812 
        new_w = bottom*render->ctx_width/render->ctx_height;
825 
    };
 813 
    };
826 
 
 814 
 
827 
    render->win_width  = right;
 815 
    render->win_width  = right;
828 
    render->win_height = bottom;
 816 
    render->win_height = bottom;
829 
    render_set_size(render, new_w, new_h);
 817 
    render_set_size(render, new_w, new_h);
830 
 
 818 
 
831 
    if(render->caps & HW_TEX_BLIT)          /*  hw scaler  */
 819 
    if(render->caps & HW_TEX_BLIT)          /*  hw scaler  */
832 
        return;
 820 
    {
- 
 
 821 
        if(render->win->win_state == FULLSCREEN)
- 
 
 822 
            pxResizeClient(render->rcvideo.l, render->rcvideo.t, new_w, new_h);
- 
 
 823 
        else
- 
 
 824 
            pxResizeClient(render->rcvideo.l, render->rcvideo.t+CAPTION_HEIGHT, new_w, new_h);
- 
 
 825 
 
- 
 
 826 
        return;
833 
 
 827 
    };
- 
 
 828 
 
834 
    render->bitmap[0].width  = new_w;
 - 
 
835 
    render->bitmap[0].height = new_h;
 - 
 
836 
    resize_bitmap(&render->bitmap[0]);
 829 
    pxResizeBitmap(render->bitmap[0], new_w, new_h);
837 
 
 830 
 
838 
    if(render->caps & HW_BIT_BLIT)          /* hw blitter */
 - 
 
839 
    {
 - 
 
840 
        render->bitmap[1].width  = new_w;
 - 
 
841 
        render->bitmap[1].height = new_h;
 831 
    if(render->caps & HW_BIT_BLIT)          /* hw blitter */
842 
        resize_bitmap(&render->bitmap[1]);
 832 
        pxResizeBitmap(render->bitmap[1], new_w, new_h);
843 
    };
 833 
 
844 
    return;
 834 
    return;
845 
};
 835 
};
846 
 
 836 
 
847 
void draw_hw_picture(render_t *render, AVPicture *picture)
 837 
void draw_hw_picture(render_t *render, AVPicture *picture)
848 
{
 838 
{
849 
    int      dst_width, dst_height;
 839 
    int       dst_width;
- 
 
 840 
    int       dst_height;
850 
    bitmap_t   *bitmap;
 841 
    bitmap_t *bitmap;
851 
    uint8_t    *data[4];
 842 
    uint8_t  *bitmap_data;
- 
 
 843 
    uint32_t  bitmap_pitch;
- 
 
 844 
    uint8_t  *data[4];
852 
    int      linesize[4];
 845 
    int       linesize[4];
853 
    int ret;
 846 
 
854 
 
 - 
 
855 
    if(render->win->win_state == MINIMIZED ||
 847 
    if(render->win->win_state == MINIMIZED ||
856 
       render->win->win_state == ROLLED)
 848 
       render->win->win_state == ROLLED)
857 
        return;
 849 
        return;
858 
 
 850 
 
859 
    if(render->caps & HW_TEX_BLIT)
 851 
    if(render->caps & HW_TEX_BLIT)
860 
    {
 852 
    {
861 
        dst_width  = render->ctx_width;
 853 
        dst_width  = render->ctx_width;
862 
        dst_height = render->ctx_height;
 854 
        dst_height = render->ctx_height;
863 
    }
 855 
    }
864 
    else
 856 
    else
865 
    {
 857 
    {
866 
        dst_width  = render->rcvideo.r;
 858 
        dst_width  = render->rcvideo.r;
867 
        dst_height = render->rcvideo.b;
 859 
        dst_height = render->rcvideo.b;
868 
    };
 860 
    };
869 
 
 861 
 
870 
    cvt_ctx = sws_getCachedContext(cvt_ctx,
 862 
    cvt_ctx = sws_getCachedContext(cvt_ctx,
871 
              render->ctx_width, render->ctx_height, render->ctx_format,
 863 
              render->ctx_width, render->ctx_height, render->ctx_format,
872 
              dst_width, dst_height, PIX_FMT_BGRA,
 864 
              dst_width, dst_height, PIX_FMT_BGRA,
873 
              SWS_FAST_BILINEAR, NULL, NULL, NULL);
 865 
              SWS_FAST_BILINEAR, NULL, NULL, NULL);
874 
    if(cvt_ctx == NULL)
 866 
    if(cvt_ctx == NULL)
875 
    {
 867 
    {
876 
        printf("Cannot initialize the conversion context!\n");
 868 
        printf("Cannot initialize the conversion context!\n");
877 
        return ;
 869 
        return ;
878 
    };
 870 
    };
879 
 
 871 
 
880 
    bitmap = &render->bitmap[render->target];
 872 
    bitmap = render->bitmap[render->target];
881 
 
 873 
 
882 
    ret = lock_bitmap(bitmap);
 874 
    bitmap_data = pxLockBitmap(bitmap, &bitmap_pitch);
883 
    if( ret != 0)
 875 
    if( bitmap_data == NULL)
884 
    {
 876 
    {
885 
        printf("Cannot lock bitmap!\n");
 877 
        printf("Cannot lock bitmap!\n");
886 
        return ;
 878 
        return ;
887 
    }
 879 
    }
888 
 
 880 
 
889 
//    printf("sws_getCachedContext\n");
 881 
//    printf("sws_getCachedContext\n");
890 
    data[0] = bitmap->data;
 882 
    data[0] = bitmap_data;
891 
    data[1] = bitmap->data+1;
 883 
    data[1] = bitmap_data+1;
892 
    data[2] = bitmap->data+2;
 884 
    data[2] = bitmap_data+2;
893 
    data[3] = bitmap->data+3;
 885 
    data[3] = bitmap_data+3;
894 
 
 886 
 
895 
    linesize[0] = bitmap->pitch;
 887 
    linesize[0] = bitmap_pitch;
896 
    linesize[1] = bitmap->pitch;
 888 
    linesize[1] = bitmap_pitch;
897 
    linesize[2] = bitmap->pitch;
 889 
    linesize[2] = bitmap_pitch;
898 
    linesize[3] = bitmap->pitch;
 890 
    linesize[3] = bitmap_pitch;
899 
 
 891 
 
900 
    sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
 892 
    sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
901 
              picture->linesize, 0, render->ctx_height, data, linesize);
 893 
              picture->linesize, 0, render->ctx_height, data, linesize);
902 
//    printf("sws_scale\n");
 894 
//    printf("sws_scale\n");
903 
 
 895 
 
904 
 
 896 
 
905 
    if(render->caps & HW_TEX_BLIT)
 897 
    if(render->caps & HW_TEX_BLIT)
906 
    {
 898 
    {
907 
 
 899 
 
908 
        if(render->win->win_state == FULLSCREEN)
 900 
        if(render->win->win_state == FULLSCREEN)
909 
            fplay_blit_bitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
 901 
            pxBlitBitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
910 
                 render->rcvideo.r, render->rcvideo.b);
 902 
                 render->rcvideo.r, render->rcvideo.b,0,0);
911 
        else
 903 
        else
912 
            fplay_blit_bitmap(bitmap, render->rcvideo.l,
 904 
            pxBlitBitmap(bitmap, render->rcvideo.l,
913 
                    CAPTION_HEIGHT+render->rcvideo.t,
 905 
                    CAPTION_HEIGHT+render->rcvideo.t,
914 
                    render->rcvideo.r, render->rcvideo.b);
 906 
                    render->rcvideo.r, render->rcvideo.b,0,0);
915 
    }
 907 
    }
916 
    else
 908 
    else
917 
    {
 909 
    {
918 
        if(render->win->win_state == FULLSCREEN)
 910 
        if(render->win->win_state == FULLSCREEN)
919 
            blit_bitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
 911 
            pxBlitBitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
920 
                    render->rcvideo.r, render->rcvideo.b, 0,0);
 912 
                    render->rcvideo.r, render->rcvideo.b, 0,0);
921 
        else
 913 
        else
922 
            blit_bitmap(bitmap, render->rcvideo.l,
 914 
            pxBlitBitmap(bitmap, render->rcvideo.l,
923 
                    CAPTION_HEIGHT+render->rcvideo.t,
 915 
                    CAPTION_HEIGHT+render->rcvideo.t,
924 
                    render->rcvideo.r, render->rcvideo.b, 0, 0);
 916 
                    render->rcvideo.r, render->rcvideo.b, 0, 0);
925 
    };
 917 
    };
926 
 
 918 
 
927 
    render->last_bitmap = bitmap;
 919 
    render->last_bitmap = bitmap;
928 
    render->target++;
 920 
    render->target++;
929 
    render->target&= 1;
 921 
    render->target&= 1;
930 
}
 922 
}
931 
 
 923 
 
932 
void draw_sw_picture(render_t *render, AVPicture *picture)
 924 
void draw_sw_picture(render_t *render, AVPicture *picture)
933 
{
 925 
{
934 
    uint8_t     *data[4];
 926 
    uint8_t  *bitmap_data;
- 
 
 927 
    uint32_t  bitmap_pitch;
- 
 
 928 
    uint8_t     *data[4];
935 
    int      linesize[4];
 929 
    int      linesize[4];
936 
 
 930 
 
937 
    if(render->win->win_state == MINIMIZED ||
 931 
    if(render->win->win_state == MINIMIZED ||
938 
       render->win->win_state == ROLLED)
 932 
       render->win->win_state == ROLLED)
939 
        return;
 933 
        return;
940 
 
 934 
 
941 
    cvt_ctx = sws_getCachedContext(cvt_ctx,
 935 
    cvt_ctx = sws_getCachedContext(cvt_ctx,
942 
              render->ctx_width, render->ctx_height,
 936 
              render->ctx_width, render->ctx_height,
943 
              render->ctx_format,
 937 
              render->ctx_format,
944 
              render->rcvideo.r, render->rcvideo.b,
 938 
              render->rcvideo.r, render->rcvideo.b,
945 
              PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);
 939 
              PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);
946 
    if(cvt_ctx == NULL)
 940 
    if(cvt_ctx == NULL)
947 
    {
 941 
    {
948 
        printf("Cannot initialize the conversion context!\n");
 942 
        printf("Cannot initialize the conversion context!\n");
949 
        return ;
 943 
        return ;
950 
    }
 944 
    }
951 
 
 945 
 
952 
    lock_bitmap(&render->bitmap[0]);
 946 
    bitmap_data = pxLockBitmap(render->bitmap[0],&bitmap_pitch);
953 
 
 947 
 
954 
    data[0] = render->bitmap[0].data;
 948 
    data[0] = bitmap_data;
955 
    data[1] = render->bitmap[0].data+1;
 949 
    data[1] = bitmap_data+1;
956 
    data[2] = render->bitmap[0].data+2;
 950 
    data[2] = bitmap_data+2;
957 
    data[3] = render->bitmap[0].data+3;
 951 
    data[3] = bitmap_data+3;
958 
 
 952 
 
959 
    linesize[0] = render->bitmap[0].pitch;
 953 
    linesize[0] = bitmap_pitch;
960 
    linesize[1] = render->bitmap[0].pitch;
 954 
    linesize[1] = bitmap_pitch;
961 
    linesize[2] = render->bitmap[0].pitch;
 955 
    linesize[2] = bitmap_pitch;
962 
    linesize[3] = render->bitmap[0].pitch;
 956 
    linesize[3] = bitmap_pitch;
963 
 
 957 
 
964 
     sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
 958 
     sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
965 
              picture->linesize, 0, render->ctx_height, data, linesize);
 959 
              picture->linesize, 0, render->ctx_height, data, linesize);
966 
 
 960 
 
967 
    if(render->win->win_state == FULLSCREEN)
 961 
    if(render->win->win_state == FULLSCREEN)
968 
        fplay_blit_bitmap(&render->bitmap[0],render->rcvideo.l,render->rcvideo.t,
 962 
        pxBlitBitmap(render->bitmap[0],render->rcvideo.l,render->rcvideo.t,
969 
                 render->rcvideo.r, render->rcvideo.b);
 963 
                 render->rcvideo.r, render->rcvideo.b,0,0);
970 
    else
 964 
    else
971 
        fplay_blit_bitmap(&render->bitmap[0], render->rcvideo.l,
 965 
        pxBlitBitmap(render->bitmap[0], render->rcvideo.l,
972 
                 CAPTION_HEIGHT+render->rcvideo.t,
 966 
                 CAPTION_HEIGHT+render->rcvideo.t,
973 
                 render->rcvideo.r, render->rcvideo.b);
 967 
                 render->rcvideo.r, render->rcvideo.b,0,0);
974 
 
 968 
 
975 
    render->last_bitmap = &render->bitmap[0];
 969 
    render->last_bitmap = render->bitmap[0];
976 
}
 970 
}
977 
 
 971 
 
978 
void render_draw_client(render_t *render)
 972 
void render_draw_client(render_t *render)
979 
{
 973 
{
980 
    int y;
 974 
    int y;
981 
 
 975 
 
982 
    if(render->win_state == MINIMIZED ||
 976 
    if(render->win_state == MINIMIZED ||
983 
       render->win_state == ROLLED )
 977 
       render->win_state == ROLLED )
984 
        return;
 978 
        return;
985 
    if(render->win_state == FULLSCREEN)
 979 
    if(render->win_state == FULLSCREEN)
986 
        y = 0;
 980 
        y = 0;
987 
    else
 981 
    else
988 
        y = CAPTION_HEIGHT;
 982 
        y = CAPTION_HEIGHT;
989 
 
 983 
 
990 
    if(player_state == PAUSE)
 984 
    if(player_state == PAUSE)
991 
    {
 985 
    {
992 
         if(frames[vfx].ready == 1 )
 986 
         if(frames[vfx].ready == 1 )
993 
            main_render->draw(main_render, &frames[vfx].picture);
 987 
            main_render->draw(main_render, &frames[vfx].picture);
994 
         else
 988 
         else
995 
            draw_bar(0, y, render->win_width,
 989 
            draw_bar(0, y, render->win_width,
996 
                 render->rcvideo.b, 0);
 990 
                 render->rcvideo.b, 0);
997 
    }
 991 
    }
998 
    else if( player_state == STOP )
 992 
    else if( player_state == STOP )
999 
    {
 993 
    {
1000 
        draw_bar(0,y, render->win_width,
 994 
        draw_bar(0,y, render->win_width,
1001 
                 render->rcvideo.b, 0);
 995 
                 render->rcvideo.b, 0);
1002 
    };
 996 
    };
1003 
 
 997 
 
1004 
    if(render->layout & HAS_TOP)
 998 
    if(render->layout & HAS_TOP)
1005 
        draw_bar(0, y, render->win_width,
 999 
        draw_bar(0, y, render->win_width,
1006 
                 render->rctop.b, 0);
 1000 
                 render->rctop.b, 0);
1007 
    if(render->layout & HAS_LEFT)
 1001 
    if(render->layout & HAS_LEFT)
1008 
        draw_bar(0, render->rcvideo.t+y, render->rcleft.r,
 1002 
        draw_bar(0, render->rcvideo.t+y, render->rcleft.r,
1009 
                 render->rcvideo.b, 0);
 1003 
                 render->rcvideo.b, 0);
1010 
    if(render->layout & HAS_RIGHT)
 1004 
    if(render->layout & HAS_RIGHT)
1011 
        draw_bar(render->rcright.l, render->rcvideo.t+y,
 1005 
        draw_bar(render->rcright.l, render->rcvideo.t+y,
1012 
                 render->rcright.r, render->rcvideo.b, 0);
 1006 
                 render->rcright.r, render->rcvideo.b, 0);
1013 
    if(render->layout & HAS_BOTTOM)
 1007 
    if(render->layout & HAS_BOTTOM)
1014 
        draw_bar(0, render->rcbottom.t+y,
 1008 
        draw_bar(0, render->rcbottom.t+y,
1015 
                 render->win_width, render->rcbottom.b, 0);
 1009 
                 render->win_width, render->rcbottom.b, 0);
1016 
}
 1010 
}
1017 
>
 1011 
>