Subversion Repositories Kolibri OS

Rev

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

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