WebSVN – Kolibri OS – Diff – /contrib/media/fplay/video.c


#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
#include "winlib/winlib.h"
#include "fplay.h"
 
int fplay_blit_bitmap(bitmap_t *bitmap, int dst_x, int dst_y,int w, int h);
void draw_va_picture(render_t *render, AVPicture *picture);
 
extern int res_pause_btn[];
extern int res_pause_btn_pressed[];
 
extern int res_play_btn[];
extern int res_play_btn_pressed[];
 
extern int64_t stream_duration;
extern volatile int sound_level_0;
extern volatile int sound_level_1;
 
typedef struct
{
    AVPicture      picture;
    double         pts;
    volatile int   ready;
}vframe_t;
 
vframe_t           frames[4];
volatile int      frames_count = 0;
 
struct SwsContext *cvt_ctx = NULL;
 
int vfx    = 0;
int dfx    = 0;
 
render_t   *main_render;
 
int width;
int height;
 
AVRational video_time_base;
AVFrame  *Frame;
 
 
 
void get_client_rect(rect_t *rc);
 
void flush_video()
{
    int i;
 
    for(i = 0; i < 4; i++)
    {
        frames[i].pts    = 0;
        frames[i].ready  = 0;
    };
    frames_count = 0;
    vfx    = 0;
    dfx    = 0;
};
 
int init_video(vst_t *vst)
{
    int        i;
 
    width = vst->vCtx->width;
    height = vst->vCtx->height;
 
    Frame = av_frame_alloc();
    if ( Frame == NULL )
    {
        printf("Cannot alloc video frame\n\r");
        return 0;
    };
 
    for( i=0; i < 4; i++)
    {
        int ret;
 
        ret = avpicture_alloc(&frames[i].picture, vst->vCtx->pix_fmt,
                               vst->vCtx->width, vst->vCtx->height);
        if ( ret != 0 )
        {
            printf("Cannot alloc video buffer\n\r");
            return 0;
        };
 
        frames[i].pts    = 0;
        frames[i].ready  = 0;
    };
 
    create_thread(video_thread, vst, 1024*1024);
 
    delay(50);
    return 1;
};
 
int decode_video(vst_t* vst)
{
    AVPacket   pkt;
    double     pts;
    int frameFinished;
    double current_clock;
 
    if(frames[dfx].ready != 0 )
        return -1;
 
    if( get_packet(&vst->q_video, &pkt) == 0 )
        return 0;
 
/*
    current_clock = -90.0 + get_master_clock();
 
    if( pkt.dts == AV_NOPTS_VALUE &&
        Frame->reordered_opaque != AV_NOPTS_VALUE)
        pts = Frame->reordered_opaque;
    else if(pkt.dts != AV_NOPTS_VALUE)
        pts= pkt.dts;
    else
        pts= 0;
 
 
    pts *= av_q2d(video_time_base)*1000.0;
*/
    if( 1 /*pts > current_clock*/)
    {
        frameFinished = 0;
 
        vst->vCtx->reordered_opaque = pkt.pts;
 
        mutex_lock(&vst->gpu_lock);
 
        if(avcodec_decode_video2(vst->vCtx, Frame, &frameFinished, &pkt) <= 0)
            printf("video decoder error\n");
 
        if(frameFinished)
        {
            AVPicture *dst_pic;
 
            if( pkt.dts == AV_NOPTS_VALUE &&
                Frame->reordered_opaque != AV_NOPTS_VALUE)
                pts = Frame->reordered_opaque;
            else if(pkt.dts != AV_NOPTS_VALUE)
                pts= pkt.dts;
            else
                pts= 0;
 
            pts *= av_q2d(video_time_base);
 
            dst_pic = &frames[dfx].picture;
 
            av_image_copy(dst_pic->data, dst_pic->linesize,
                      (const uint8_t**)Frame->data,
                      Frame->linesize, vst->vCtx->pix_fmt, vst->vCtx->width, vst->vCtx->height);
 
            frames[dfx].pts = pts*1000.0;
 
            frames[dfx].ready = 1;
 
            dfx++;
            dfx&= 3;
            frames_count++;
        };
        mutex_unlock(&vst->gpu_lock);
 
    };
    av_free_packet(&pkt);
 
    return 1;
}
 
extern volatile enum player_state player_state;
extern volatile enum player_state decoder_state;
extern volatile enum player_state sound_state;
 
extern int64_t rewind_pos;
 
static void player_stop()
{
    window_t  *win;
 
    win = main_render->win;
 
    rewind_pos = 0;
 
    win->panel.play_btn->img_default    = res_play_btn;
    win->panel.play_btn->img_hilite     = res_play_btn;
    win->panel.play_btn->img_pressed    = res_play_btn_pressed;
    win->panel.prg->current             = rewind_pos;
 
    send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
    player_state = STOP;
    decoder_state = PLAY_2_STOP;
    sound_state = PLAY_2_STOP;
    render_draw_client(main_render);
};
 
int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
{
    window_t  *win = (window_t*)ctrl;
    static int spc_down = 0;
    static int ent_down = 0;
 
    switch(msg)
    {
        case MSG_SIZE:
            if(main_render)
            {
                render_adjust_size(main_render, win);
                render_draw_client(main_render);
            };
            break;
 
        case MSG_KEY:
            switch((short)arg2)
            {
                case 0x39:
                    if(spc_down == 0)
                    {
                        spc_down = 1;
                        send_message(win, MSG_LBTNDOWN, 0, 0);
                    }
                    break;
 
                case 0xB9:
                    spc_down = 0;
                    break;
 
                case 0x1C:
                    if(ent_down == 0)
                    {
                        int screensize;
                        if(win->win_state == NORMAL)
                        {
                            win->saved = win->rc;
                            win->saved_state = win->win_state;
 
                            screensize = GetScreenSize();
                            __asm__ __volatile__(
                            "int $0x40"
                            ::"a"(67), "b"(0), "c"(0),
                            "d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );
                            win->win_state = FULLSCREEN;
                            window_update_layout(win);
                        }
                        else if(win->win_state == FULLSCREEN)
                        {
                            __asm__ __volatile__(
                            "int $0x40"
                            ::"a"(67), "b"(win->saved.l), "c"(win->saved.t),
                            "d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));
                            win->win_state = win->saved_state;
                            window_update_layout(win);
//                            if(win->saved_state == MAXIMIZED)
//                            {
//                                blit_caption(&win->caption);
//                                blit_panel(&win->panel);
//                            }
                        }
                        ent_down = 1;
                    };
                    break;
 
                case 0x9C:
                    ent_down = 0;
                    break;
            };
 
        case MSG_DRAW_CLIENT:
            if(main_render)
            {
                render_draw_client(main_render);
            };
            break;
 
        case MSG_LBTNDOWN:
 
            if(player_state == PAUSE)
            {
                win->panel.play_btn->img_default = res_pause_btn;
                win->panel.play_btn->img_hilite  = res_pause_btn;
                win->panel.play_btn->img_pressed = res_pause_btn_pressed;
                send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
                player_state = PLAY;
                sound_state  = PAUSE_2_PLAY;
 
            }
            else if(player_state == PLAY)
            {
                win->panel.play_btn->img_default = res_play_btn;
                win->panel.play_btn->img_hilite  = res_play_btn;
                win->panel.play_btn->img_pressed = res_play_btn_pressed;
                send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
                player_state = PAUSE;
                sound_state  = PLAY_2_PAUSE;
            }
            break;
 
        case MSG_COMMAND:
            switch((short)arg1)
            {
                case ID_PLAY:
                    if(player_state == PAUSE)
                    {
                        win->panel.play_btn->img_default  = res_pause_btn;
                        win->panel.play_btn->img_hilite   = res_pause_btn;
                        win->panel.play_btn->img_pressed = res_pause_btn_pressed;
                        player_state = PLAY;
                        sound_state = PAUSE_2_PLAY;
                    }
                    else if(player_state == PLAY)
                    {
                        win->panel.play_btn->img_default = res_play_btn;
                        win->panel.play_btn->img_hilite  = res_play_btn;
                        win->panel.play_btn->img_pressed  = res_play_btn_pressed;
                        player_state = PAUSE;
                        sound_state  = PLAY_2_PAUSE;
                    }
                    else if(player_state == STOP)
                    {
                        win->panel.play_btn->img_default  = res_pause_btn;
                        win->panel.play_btn->img_hilite   = res_pause_btn;
                        win->panel.play_btn->img_pressed = res_pause_btn_pressed;
                        rewind_pos = 0;
                        send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
                        player_state = PLAY;
                        decoder_state = PREPARE;
                    }
                    break;
 
                case ID_STOP:
                    player_stop();
                    break;
 
                case ID_PROGRESS:
                    if(player_state != REWIND)
                    {
                        progress_t *prg = (progress_t*)arg2;
 
                        rewind_pos = (prg->max - prg->min)*prg->pos/prg->ctrl.w;
 
                        player_state  = REWIND;
                        decoder_state = REWIND;
                        sound_state   = PLAY_2_STOP;
                        if(rewind_pos < prg->current)
                        {
                            prg->current  = rewind_pos;
                            rewind_pos = -rewind_pos;
                        }
                        else
                            prg->current  = rewind_pos;
 
                        win->panel.play_btn->img_default  = res_pause_btn;
                        win->panel.play_btn->img_hilite   = res_pause_btn;
                        win->panel.play_btn->img_pressed  = res_pause_btn_pressed;
                        send_message(&prg->ctrl, MSG_PAINT, 0, 0);
                    };
                    break;
 
                case ID_VOL_CTRL:
                {
                    slider_t *sld = (slider_t*)arg2;
                    int      peak;
                    int      level;
 
                    peak = sld->min + sld->pos * (sld->max - sld->min)/(96);
                    level =  peak;
 
                    set_audio_volume(level, level);
                    send_message(&sld->ctrl, MSG_PAINT, 0, 0);
                    win->panel.lvl->vol = level;
                }
 
                default:
                    break;
            }
            break;
 
        default:
            def_window_proc(ctrl,msg,arg1,arg2);
    };
    return 0;
};
 
#define VERSION_A     1
 
 
 
 
void render_time(render_t *render)
{
    progress_t  *prg = main_render->win->panel.prg;
    level_t     *lvl = main_render->win->panel.lvl;
 
    double      ctime;            /*    milliseconds    */
    double      fdelay;           /*    milliseconds    */
 
//again:
 
    if(player_state == CLOSED)
    {
        render->win->win_command = WIN_CLOSED;
        return;
    }
    else if((player_state == PAUSE) || (player_state == REWIND))
    {
        delay(1);
        return;
    }
    else if (decoder_state == STOP && frames_count  == 0 &&
              player_state  != STOP)
    {
        player_stop();
    }
    else if(player_state != PLAY)
    {
        delay(1);
        return;
    };
 
 
#ifdef VERSION_A
    if(frames[vfx].ready == 1 )
    {
        int sys_time;
 
        ctime = get_master_clock();
        fdelay = (frames[vfx].pts - ctime);
 
//        printf("pts %f time %f delay %f\n",
//                frames[vfx].pts, ctime, fdelay);
 
        if(fdelay > 15.0)
        {
            delay((int)fdelay/10);
        //    return;
        };
#if 0
        ctime = get_master_clock();
        fdelay = (frames[vfx].pts - ctime);
 
//        while(fdelay > 0)
//        {
//            yield();
//            ctime = get_master_clock();
//            fdelay = (frames[vfx].pts - ctime);
//        }
 
//        sys_time = get_tick_count();
 
//        if(fdelay < 0)
//            printf("systime %d pts %f time %f delay %f\n",
//                    sys_time*10, frames[vfx].pts, ctime, fdelay);
 
        printf("pts %f time %f delay %f\n",
                frames[vfx].pts, ctime, fdelay);
        printf("video cache %d audio cache %d\n", q_video.size/1024, q_audio.size/1024);
#endif
 
        main_render->draw(main_render, &frames[vfx].picture);
        if(main_render->win->win_state != FULLSCREEN)
        {
            prg->current = frames[vfx].pts*1000;
//        printf("current %f\n", prg->current);
            lvl->current = vfx & 1 ? sound_level_1 : sound_level_0;
 
            send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);
 
            if(main_render->win->panel.layout)
                send_message(&lvl->ctrl, MSG_PAINT, 0, 0);
        }
 
        frames_count--;
        frames[vfx].ready = 0;
        vfx++;
        vfx&= 3;
    }
    else delay(1);
 
#else
 
    if(frames[vfx].ready == 1 )
    {
        ctime = get_master_clock();
        fdelay = (frames[vfx].pts - ctime);
 
//            printf("pts %f time %f delay %f\n",
//                    frames[vfx].pts, ctime, fdelay);
 
        if(fdelay < 0.0 )
        {
            int  next_vfx;
            fdelay = 0;
            next_vfx = (vfx+1) & 3;
            if( frames[next_vfx].ready == 1 )
            {
                if(frames[next_vfx].pts <= ctime)
                {
                    frames[vfx].ready = 0;                  // skip this frame
                    vfx++;
                    vfx&= 3;
                }
                else
                {
                    if( (frames[next_vfx].pts - ctime) <
                        ( ctime - frames[vfx].pts) )
                    {
                        frames[vfx].ready = 0;                  // skip this frame
                        vfx++;
                        vfx&= 3;
                        fdelay = (frames[next_vfx].pts - ctime);
                    }
                }
            };
        };
 
        if(fdelay > 10.0)
        {
           int val = fdelay;
           printf("pts %f time %f delay %d\n",
                   frames[vfx].pts, ctime, val);
           delay(val/10);
        };
 
        ctime = get_master_clock();
        fdelay = (frames[vfx].pts - ctime);
 
        printf("pts %f time %f delay %f\n",
                frames[vfx].pts, ctime, fdelay);
 
        main_render->draw(main_render, &frames[vfx].picture);
        main_render->win->panel.prg->current = frames[vfx].pts;
//        send_message(&render->win->panel.prg->ctrl, MSG_PAINT, 0, 0);
        frames[vfx].ready = 0;
        vfx++;
        vfx&= 3;
    }
    else yield();
#endif
 
}
 
 
extern char *movie_file;
 
int video_thread(void *param)
{
    vst_t *vst = param;
    window_t  *MainWindow;
 
    init_winlib();
 
    MainWindow = create_window(movie_file,0,
                               10,10,width,height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
 
    MainWindow->panel.prg->max = stream_duration;
 
    show_window(MainWindow, NORMAL);
 
 
 
    main_render = create_render(vst, MainWindow, HW_TEX_BLIT|HW_BIT_BLIT);
    if( main_render == NULL)
    {
        printf("Cannot create render\n\r");
        return 0;
    };
 
    __sync_or_and_fetch(&threads_running,VIDEO_THREAD);
 
    render_draw_client(main_render);
    player_state = PLAY;
 
    run_render(MainWindow, main_render);
 
    __sync_and_and_fetch(&threads_running,~VIDEO_THREAD);
 
    destroy_render(main_render);
    fini_winlib();
    player_state = CLOSED;
    return 0;
};
 
 
void draw_hw_picture(render_t *render, AVPicture *picture);
void draw_sw_picture(render_t *render, AVPicture *picture);
 
render_t *create_render(vst_t *vst, window_t *win, uint32_t flags)
{
    render_t *render;
 
    uint32_t right, bottom, draw_w, draw_h;
    uint32_t s, sw, sh;
    uint8_t  state;
 
//    __asm__ __volatile__("int3");
 
    render = (render_t*)malloc(sizeof(render_t));
    memset(render, 0, sizeof(render_t));
 
    render->vst = vst;
    render->win = win;
 
    render->ctx_width  = vst->vCtx->width;
    render->ctx_height = vst->vCtx->height;
    render->ctx_format = vst->vCtx->pix_fmt;
 
    render->caps = pxInit(1);
 
    right  = win->w;
    bottom = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
 
    printf("window width %d height %d\n",
                    right, bottom);
 
    render->win_state  = win->win_state;
 
    draw_w = bottom*render->ctx_width/render->ctx_height;
    draw_h = right*render->ctx_height/render->ctx_width;
 
    if(draw_w > right)
    {
        draw_w = right;
        draw_h = right*render->ctx_height/render->ctx_width;
    };
 
    if(draw_h > bottom)
    {
        draw_h = bottom;
        draw_w = bottom*render->ctx_width/render->ctx_height;
    };
 
    render->win_width  = win->w;
    render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
 
    render_set_size(render, draw_w, draw_h);
 
    pxCreateClient(0, CAPTION_HEIGHT, right, bottom);
 
    if(render->caps==0)
    {
        render->bitmap[0] = pxCreateBitmap(draw_w, draw_h);
        if(render->bitmap[0] == NULL)
        {
            free(render);
            return NULL;
        }
        render->draw = draw_sw_picture;
    }
    else
    {
        int width, height;
        int i;
 
        if(render->caps & HW_TEX_BLIT)
        {
            width  = render->ctx_width;
            height = render->ctx_height;
        }
        else
        {
            width  = draw_w;
            height = draw_h;;
        }
 
        for( i=0; i < 2; i++)
        {
            render->bitmap[i] = pxCreateBitmap(width, height);
            if( render->bitmap[i] == NULL )
            {
                player_state = CLOSED;
                free(render);
                return NULL;
            };
        }
 
        render->state = INIT;
        render->target = 0;
        render->draw   = draw_hw_picture;
    };
 
    printf("FPlay %s render engine: context %dx%d picture %dx%d\n",
           render->caps & HW_TEX_BLIT ? "hw_tex_blit":
           render->caps & HW_BIT_BLIT ? "hw_bit_blit":"software",
           render->ctx_width, render->ctx_height,
           draw_w, draw_h);
 
    return render;
};
 
void destroy_render(render_t *render)
{
 
    pxDestroyBitmap(render->bitmap[0]);
 
    if(render->caps & (HW_BIT_BLIT|HW_TEX_BLIT))          /* hw blitter */
        pxDestroyBitmap(render->bitmap[1]);
 
    pxFini();
};
 
void render_set_size(render_t *render, int width, int height)
{
    int i;
 
    render->layout = 0;
    render->rcvideo.l = 0;
    render->rcvideo.t = 0;
    render->rcvideo.r = width;
    render->rcvideo.b = height;
 
//    printf("render width %d height %d\n",width, height);
 
    if( render->win_height > height )
    {
        int yoffs;
        yoffs = (render->win_height-height)/2;
        if(yoffs)
        {
            render->rctop.t = 0;
            render->rctop.b = yoffs;
            render->rcvideo.t  = yoffs;
            render->layout |= HAS_TOP;
        }
 
        yoffs = render->win_height-(render->rcvideo.t+render->rcvideo.b);
        if(yoffs)
        {
            render->rcbottom.t = render->rcvideo.t+render->rcvideo.b;
            render->rcbottom.b = yoffs;
            render->layout |= HAS_BOTTOM;
        }
    }
 
    if( render->win_width > width )
    {
        int xoffs;
        xoffs = (render->win_width-width)/2;
        if(xoffs)
        {
            render->rcleft.r  = xoffs;
            render->rcvideo.l = xoffs;
            render->layout |= HAS_LEFT;
        }
        xoffs = render->win_width-(render->rcvideo.l+render->rcvideo.r);
        if(xoffs)
        {
            render->rcright.l = render->rcvideo.l+render->rcvideo.r;
            render->rcright.r = xoffs;
            render->layout |= HAS_RIGHT;
        }
    };
};
 
void render_adjust_size(render_t *render, window_t *win)
{
    uint32_t right, bottom, new_w, new_h;
    uint32_t s, sw, sh;
    uint8_t  state;
 
    right  = win->w;
    bottom = win->h;
 
    if(win->win_state != FULLSCREEN)
        bottom-= CAPTION_HEIGHT+PANEL_HEIGHT;
 
 //   printf("window width %d height %d\n",
 //                   right, bottom);
 
    render->win_state  = win->win_state;
 
    if(render->win_state == MINIMIZED)
        return;
 
    if(render->win_state == ROLLED)
        return;
 
    if( right  == render->win_width &&
        bottom == render->win_height)
        return;
 
//    printf("%s r: %d b: %d\n", __FUNCTION__, right, bottom);
 
    new_w = bottom*render->ctx_width/render->ctx_height;
    new_h = right*render->ctx_height/render->ctx_width;
 
    if(new_w > right)
    {
        new_w = right;
        new_h = right*render->ctx_height/render->ctx_width;
    };
    if(new_h > bottom)
    {
        new_h = bottom;
        new_w = bottom*render->ctx_width/render->ctx_height;
    };
 
    render->win_width  = right;
    render->win_height = bottom;
    render_set_size(render, new_w, new_h);
 
    if(render->caps & HW_TEX_BLIT)          /*  hw scaler  */
    {
        if(render->win->win_state == FULLSCREEN)
            pxResizeClient(render->rcvideo.l, render->rcvideo.t, new_w, new_h);
        else
            pxResizeClient(render->rcvideo.l, render->rcvideo.t+CAPTION_HEIGHT, new_w, new_h);
 
        return;
    };
 
    pxResizeBitmap(render->bitmap[0], new_w, new_h);
 
    if(render->caps & HW_BIT_BLIT)          /* hw blitter */
        pxResizeBitmap(render->bitmap[1], new_w, new_h);
 
    return;
};
 
void draw_hw_picture(render_t *render, AVPicture *picture)
{
    int       dst_width;
    int       dst_height;
    bitmap_t *bitmap;
    uint8_t  *bitmap_data;
    uint32_t  bitmap_pitch;
    uint8_t  *data[4];
    int       linesize[4];
 
    if(render->win->win_state == MINIMIZED ||
       render->win->win_state == ROLLED)
        return;
 
    if(render->caps & HW_TEX_BLIT)
    {
        dst_width  = render->ctx_width;
        dst_height = render->ctx_height;
    }
    else
    {
        dst_width  = render->rcvideo.r;
        dst_height = render->rcvideo.b;
    };
 
    cvt_ctx = sws_getCachedContext(cvt_ctx,
              render->ctx_width, render->ctx_height, render->ctx_format,
              dst_width, dst_height, AV_PIX_FMT_BGRA,
              SWS_FAST_BILINEAR, NULL, NULL, NULL);
    if(cvt_ctx == NULL)
    {
        printf("Cannot initialize the conversion context!\n");
        return ;
    };
 
    bitmap = render->bitmap[render->target];
 
    bitmap_data = pxLockBitmap(bitmap, &bitmap_pitch);
    if( bitmap_data == NULL)
    {
        printf("Cannot lock bitmap!\n");
        return ;
    }
 
//    printf("sws_getCachedContext\n");
    data[0] = bitmap_data;
    data[1] = bitmap_data+1;
    data[2] = bitmap_data+2;
    data[3] = bitmap_data+3;
 
    linesize[0] = bitmap_pitch;
    linesize[1] = bitmap_pitch;
    linesize[2] = bitmap_pitch;
    linesize[3] = bitmap_pitch;
 
    sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
              picture->linesize, 0, render->ctx_height, data, linesize);
//    printf("sws_scale\n");
 
    mutex_lock(&render->vst->gpu_lock);
 
    if(render->caps & HW_TEX_BLIT)
    {
 
        if(render->win->win_state == FULLSCREEN)
            pxBlitBitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
                 render->rcvideo.r, render->rcvideo.b,0,0);
        else
            pxBlitBitmap(bitmap, render->rcvideo.l,
                    CAPTION_HEIGHT+render->rcvideo.t,
                    render->rcvideo.r, render->rcvideo.b,0,0);
    }
    else
    {
        if(render->win->win_state == FULLSCREEN)
            pxBlitBitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
                    render->rcvideo.r, render->rcvideo.b, 0,0);
        else
            pxBlitBitmap(bitmap, render->rcvideo.l,
                    CAPTION_HEIGHT+render->rcvideo.t,
                    render->rcvideo.r, render->rcvideo.b, 0, 0);
    };
    mutex_unlock(&render->vst->gpu_lock);
 
    render->last_bitmap = bitmap;
    render->target++;
    render->target&= 1;
}
 
void draw_sw_picture(render_t *render, AVPicture *picture)
{
    uint8_t  *bitmap_data;
    uint32_t  bitmap_pitch;
    uint8_t     *data[4];
    int      linesize[4];
 
    if(render->win->win_state == MINIMIZED ||
       render->win->win_state == ROLLED)
        return;
 
    cvt_ctx = sws_getCachedContext(cvt_ctx,
              render->ctx_width, render->ctx_height,
              render->ctx_format,
              render->rcvideo.r, render->rcvideo.b,
              AV_PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);
    if(cvt_ctx == NULL)
    {
        printf("Cannot initialize the conversion context!\n");
        return ;
    }
 
    bitmap_data = pxLockBitmap(render->bitmap[0],&bitmap_pitch);
 
    data[0] = bitmap_data;
    data[1] = bitmap_data+1;
    data[2] = bitmap_data+2;
    data[3] = bitmap_data+3;
 
    linesize[0] = bitmap_pitch;
    linesize[1] = bitmap_pitch;
    linesize[2] = bitmap_pitch;
    linesize[3] = bitmap_pitch;
 
     sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
              picture->linesize, 0, render->ctx_height, data, linesize);
 
    if(render->win->win_state == FULLSCREEN)
        pxBlitBitmap(render->bitmap[0],render->rcvideo.l,render->rcvideo.t,
                 render->rcvideo.r, render->rcvideo.b,0,0);
    else
        pxBlitBitmap(render->bitmap[0], render->rcvideo.l,
                 CAPTION_HEIGHT+render->rcvideo.t,
                 render->rcvideo.r, render->rcvideo.b,0,0);
 
    render->last_bitmap = render->bitmap[0];
}
 
void render_draw_client(render_t *render)
{
    int y;
 
    if(render->win_state == MINIMIZED ||
       render->win_state == ROLLED )
        return;
    if(render->win_state == FULLSCREEN)
        y = 0;
    else
        y = CAPTION_HEIGHT;
 
    if(player_state == PAUSE)
    {
         if(frames[vfx].ready == 1 )
            main_render->draw(main_render, &frames[vfx].picture);
         else
            draw_bar(0, y, render->win_width,
                 render->rcvideo.b, 0);
    }
    else if( player_state == STOP )
    {
        draw_bar(0,y, render->win_width,
                 render->rcvideo.b, 0);
    };
 
    if(render->layout & HAS_TOP)
        draw_bar(0, y, render->win_width,
                 render->rctop.b, 0);
    if(render->layout & HAS_LEFT)
        draw_bar(0, render->rcvideo.t+y, render->rcleft.r,
                 render->rcvideo.b, 0);
    if(render->layout & HAS_RIGHT)
        draw_bar(render->rcright.l, render->rcvideo.t+y,
                 render->rcright.r, render->rcvideo.b, 0);
    if(render->layout & HAS_BOTTOM)
        draw_bar(0, render->rcbottom.t+y,
                 render->win_width, render->rcbottom.b, 0);
}
>

Rev 6106	Rev 6117
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);	13	int fplay_blit_bitmap(bitmap_t *bitmap, int dst_x, int dst_y,int w, int h);
14	void draw_va_picture(render_t render, AVPicture picture);	14	void draw_va_picture(render_t render, AVPicture picture);
15		15
16	extern int res_pause_btn[];	16	extern int res_pause_btn[];
17	extern int res_pause_btn_pressed[];	17	extern int res_pause_btn_pressed[];
18		18
19	extern int res_play_btn[];	19	extern int res_play_btn[];
20	extern int res_play_btn_pressed[];	20	extern int res_play_btn_pressed[];
21		21
22	extern int64_t stream_duration;	22	extern int64_t stream_duration;
23	extern volatile int sound_level_0;	23	extern volatile int sound_level_0;
24	extern volatile int sound_level_1;	24	extern volatile int sound_level_1;
25		25
26	typedef struct	26	typedef struct
27	{	27	{
28	AVPicture picture;	28	AVPicture picture;
29	double pts;	29	double pts;
30	volatile int ready;	30	volatile int ready;
31	}vframe_t;	31	}vframe_t;
32		32
33	vframe_t frames[4];	33	vframe_t frames[4];
34	volatile int frames_count = 0;	34	volatile int frames_count = 0;
35		35
36	struct SwsContext *cvt_ctx = NULL;	36	struct SwsContext *cvt_ctx = NULL;
37		37
38	int vfx = 0;	38	int vfx = 0;
39	int dfx = 0;	39	int dfx = 0;
40		40
41	render_t *main_render;	41	render_t *main_render;
42		42
43	int width;	43	int width;
44	int height;	44	int height;
45		45
46	AVRational video_time_base;	46	AVRational video_time_base;
47	AVFrame *Frame;	47	AVFrame *Frame;
48		48
49	extern mutex_t driver_lock;	-
50		-
51	void get_client_rect(rect_t *rc);	49	void get_client_rect(rect_t *rc);
52		50
53	void flush_video()	51	void flush_video()
54	{	52	{
55	int i;	53	int i;
56		54
57	for(i = 0; i < 4; i++)	55	for(i = 0; i < 4; i++)
58	{	56	{
59	frames[i].pts = 0;	57	frames[i].pts = 0;
60	frames[i].ready = 0;	58	frames[i].ready = 0;
61	};	59	};
62	frames_count = 0;	60	frames_count = 0;
63	vfx = 0;	61	vfx = 0;
64	dfx = 0;	62	dfx = 0;
65	};	63	};
66		64
67	int init_video(AVCodecContext *ctx)	65	int init_video(vst_t *vst)
68	{	66	{
69	int i;	67	int i;
70		68
71	width = ctx->width;	69	width = vst->vCtx->width;
72	height = ctx->height;	70	height = vst->vCtx->height;
73		71
74	Frame = avcodec_alloc_frame();	72	Frame = av_frame_alloc();
75	if ( Frame == NULL )	73	if ( Frame == NULL )
76	{	74	{
77	printf("Cannot alloc video frame\n\r");	75	printf("Cannot alloc video frame\n\r");
78	return 0;	76	return 0;
79	};	77	};
80		78
81	for( i=0; i < 4; i++)	79	for( i=0; i < 4; i++)
82	{	80	{
83	int ret;	81	int ret;
84		82
85	ret = avpicture_alloc(&frames[i].picture, ctx->pix_fmt,	83	ret = avpicture_alloc(&frames[i].picture, vst->vCtx->pix_fmt,
86	ctx->width, ctx->height);	84	vst->vCtx->width, vst->vCtx->height);
87	if ( ret != 0 )	85	if ( ret != 0 )
88	{	86	{
89	printf("Cannot alloc video buffer\n\r");	87	printf("Cannot alloc video buffer\n\r");
90	return 0;	88	return 0;
91	};	89	};
92		90
93	frames[i].pts = 0;	91	frames[i].pts = 0;
94	frames[i].ready = 0;	92	frames[i].ready = 0;
95	};	93	};
96		94
97	create_thread(video_thread, ctx, 1024*1024);	95	create_thread(video_thread, vst, 1024*1024);
98		96
99	delay(50);	97	delay(50);
100	return 1;	98	return 1;
101	};	99	};
102		100
103	int decode_video(AVCodecContext ctx, queue_t qv)	101	int decode_video(vst_t* vst)
104	{	102	{
105	AVPacket pkt;	103	AVPacket pkt;
106	double pts;	104	double pts;
107	int frameFinished;	105	int frameFinished;
108	double current_clock;	106	double current_clock;
109		107
110	if(frames[dfx].ready != 0 )	108	if(frames[dfx].ready != 0 )
111	return -1;	109	return -1;
112		110
113	if( get_packet(qv, &pkt) == 0 )	111	if( get_packet(&vst->q_video, &pkt) == 0 )
114	return 0;	112	return 0;
115		113
116	/*	114	/*
117	current_clock = -90.0 + get_master_clock();	115	current_clock = -90.0 + get_master_clock();
118		116
119	if( pkt.dts == AV_NOPTS_VALUE &&	117	if( pkt.dts == AV_NOPTS_VALUE &&
120	Frame->reordered_opaque != AV_NOPTS_VALUE)	118	Frame->reordered_opaque != AV_NOPTS_VALUE)
121	pts = Frame->reordered_opaque;	119	pts = Frame->reordered_opaque;
122	else if(pkt.dts != AV_NOPTS_VALUE)	120	else if(pkt.dts != AV_NOPTS_VALUE)
123	pts= pkt.dts;	121	pts= pkt.dts;
124	else	122	else
125	pts= 0;	123	pts= 0;
126		124
127		125
128	pts = av_q2d(video_time_base)1000.0;	126	pts = av_q2d(video_time_base)1000.0;
129	*/	127	*/
130	if( 1 /pts > current_clock/)	128	if( 1 /pts > current_clock/)
131	{	129	{
132	frameFinished = 0;	130	frameFinished = 0;
133		131
134	ctx->reordered_opaque = pkt.pts;	132	vst->vCtx->reordered_opaque = pkt.pts;
-		133
-		134	mutex_lock(&vst->gpu_lock);
135		135
136	if(avcodec_decode_video2(ctx, Frame, &frameFinished, &pkt) <= 0)	136	if(avcodec_decode_video2(vst->vCtx, Frame, &frameFinished, &pkt) <= 0)
137	printf("video decoder error\n");	137	printf("video decoder error\n");
138		138
139	if(frameFinished)	139	if(frameFinished)
140	{	140	{
141	AVPicture *dst_pic;	141	AVPicture *dst_pic;
142		142
143	if( pkt.dts == AV_NOPTS_VALUE &&	143	if( pkt.dts == AV_NOPTS_VALUE &&
144	Frame->reordered_opaque != AV_NOPTS_VALUE)	144	Frame->reordered_opaque != AV_NOPTS_VALUE)
145	pts = Frame->reordered_opaque;	145	pts = Frame->reordered_opaque;
146	else if(pkt.dts != AV_NOPTS_VALUE)	146	else if(pkt.dts != AV_NOPTS_VALUE)
147	pts= pkt.dts;	147	pts= pkt.dts;
148	else	148	else
149	pts= 0;	149	pts= 0;
150		150
151	pts *= av_q2d(video_time_base);	151	pts *= av_q2d(video_time_base);
152		152
153	dst_pic = &frames[dfx].picture;	153	dst_pic = &frames[dfx].picture;
154		154
155	av_image_copy(dst_pic->data, dst_pic->linesize,	155	av_image_copy(dst_pic->data, dst_pic->linesize,
156	(const uint8_t**)Frame->data,	156	(const uint8_t**)Frame->data,
157	Frame->linesize, ctx->pix_fmt, ctx->width, ctx->height);	157	Frame->linesize, vst->vCtx->pix_fmt, vst->vCtx->width, vst->vCtx->height);
158		158
159	frames[dfx].pts = pts*1000.0;	159	frames[dfx].pts = pts*1000.0;
160		160
161	frames[dfx].ready = 1;	161	frames[dfx].ready = 1;
162		162
163	dfx++;	163	dfx++;
164	dfx&= 3;	164	dfx&= 3;
165	frames_count++;	165	frames_count++;
166	};	166	};
167	};	167	mutex_unlock(&vst->gpu_lock);
-		168
-		169	};
168	av_free_packet(&pkt);	170	av_free_packet(&pkt);
169		171
170	return 1;	172	return 1;
171	}	173	}
172		174
173	extern volatile enum player_state player_state;	175	extern volatile enum player_state player_state;
174	extern volatile enum player_state decoder_state;	176	extern volatile enum player_state decoder_state;
175	extern volatile enum player_state sound_state;	177	extern volatile enum player_state sound_state;
176		178
177	extern int64_t rewind_pos;	179	extern int64_t rewind_pos;
178		180
179	static void player_stop()	181	static void player_stop()
180	{	182	{
181	window_t *win;	183	window_t *win;
182		184
183	win = main_render->win;	185	win = main_render->win;
184		186
185	rewind_pos = 0;	187	rewind_pos = 0;
186		188
187	win->panel.play_btn->img_default = res_play_btn;	189	win->panel.play_btn->img_default = res_play_btn;
188	win->panel.play_btn->img_hilite = res_play_btn;	190	win->panel.play_btn->img_hilite = res_play_btn;
189	win->panel.play_btn->img_pressed = res_play_btn_pressed;	191	win->panel.play_btn->img_pressed = res_play_btn_pressed;
190	win->panel.prg->current = rewind_pos;	192	win->panel.prg->current = rewind_pos;
191		193
192	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);	194	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
193	player_state = STOP;	195	player_state = STOP;
194	decoder_state = PLAY_2_STOP;	196	decoder_state = PLAY_2_STOP;
195	sound_state = PLAY_2_STOP;	197	sound_state = PLAY_2_STOP;
196	render_draw_client(main_render);	198	render_draw_client(main_render);
197	};	199	};
198		200
199	int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)	201	int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
200	{	202	{
201	window_t win = (window_t)ctrl;	203	window_t win = (window_t)ctrl;
202	static int spc_down = 0;	204	static int spc_down = 0;
203	static int ent_down = 0;	205	static int ent_down = 0;
204		206
205	switch(msg)	207	switch(msg)
206	{	208	{
207	case MSG_SIZE:	209	case MSG_SIZE:
208	if(main_render)	210	if(main_render)
209	{	211	{
210	render_adjust_size(main_render, win);	212	render_adjust_size(main_render, win);
211	render_draw_client(main_render);	213	render_draw_client(main_render);
212	};	214	};
213	break;	215	break;
214		216
215	case MSG_KEY:	217	case MSG_KEY:
216	switch((short)arg2)	218	switch((short)arg2)
217	{	219	{
218	case 0x39:	220	case 0x39:
219	if(spc_down == 0)	221	if(spc_down == 0)
220	{	222	{
221	spc_down = 1;	223	spc_down = 1;
222	send_message(win, MSG_LBTNDOWN, 0, 0);	224	send_message(win, MSG_LBTNDOWN, 0, 0);
223	}	225	}
224	break;	226	break;
225		227
226	case 0xB9:	228	case 0xB9:
227	spc_down = 0;	229	spc_down = 0;
228	break;	230	break;
229		231
230	case 0x1C:	232	case 0x1C:
231	if(ent_down == 0)	233	if(ent_down == 0)
232	{	234	{
233	int screensize;	235	int screensize;
234	if(win->win_state == NORMAL)	236	if(win->win_state == NORMAL)
235	{	237	{
236	win->saved = win->rc;	238	win->saved = win->rc;
237	win->saved_state = win->win_state;	239	win->saved_state = win->win_state;
238		240
239	screensize = GetScreenSize();	241	screensize = GetScreenSize();
240	__asm__ __volatile__(	242	__asm__ __volatile__(
241	"int $0x40"	243	"int $0x40"
242	::"a"(67), "b"(0), "c"(0),	244	::"a"(67), "b"(0), "c"(0),
243	"d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );	245	"d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );
244	win->win_state = FULLSCREEN;	246	win->win_state = FULLSCREEN;
245	window_update_layout(win);	247	window_update_layout(win);
246	}	248	}
247	else if(win->win_state == FULLSCREEN)	249	else if(win->win_state == FULLSCREEN)
248	{	250	{
249	__asm__ __volatile__(	251	__asm__ __volatile__(
250	"int $0x40"	252	"int $0x40"
251	::"a"(67), "b"(win->saved.l), "c"(win->saved.t),	253	::"a"(67), "b"(win->saved.l), "c"(win->saved.t),
252	"d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));	254	"d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));
253	win->win_state = win->saved_state;	255	win->win_state = win->saved_state;
254	window_update_layout(win);	256	window_update_layout(win);
255	// if(win->saved_state == MAXIMIZED)	257	// if(win->saved_state == MAXIMIZED)
256	// {	258	// {
257	// blit_caption(&win->caption);	259	// blit_caption(&win->caption);
258	// blit_panel(&win->panel);	260	// blit_panel(&win->panel);
259	// }	261	// }
260	}	262	}
261	ent_down = 1;	263	ent_down = 1;
262	};	264	};
263	break;	265	break;
264		266
265	case 0x9C:	267	case 0x9C:
266	ent_down = 0;	268	ent_down = 0;
267	break;	269	break;
268	};	270	};
269		271
270	case MSG_DRAW_CLIENT:	272	case MSG_DRAW_CLIENT:
271	if(main_render)	273	if(main_render)
272	{	274	{
273	render_draw_client(main_render);	275	render_draw_client(main_render);
274	};	276	};
275	break;	277	break;
276		278
277	case MSG_LBTNDOWN:	279	case MSG_LBTNDOWN:
278		280
279	if(player_state == PAUSE)	281	if(player_state == PAUSE)
280	{	282	{
281	win->panel.play_btn->img_default = res_pause_btn;	283	win->panel.play_btn->img_default = res_pause_btn;
282	win->panel.play_btn->img_hilite = res_pause_btn;	284	win->panel.play_btn->img_hilite = res_pause_btn;
283	win->panel.play_btn->img_pressed = res_pause_btn_pressed;	285	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
284	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);	286	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
285	player_state = PLAY;	287	player_state = PLAY;
286	sound_state = PAUSE_2_PLAY;	288	sound_state = PAUSE_2_PLAY;
287		289
288	}	290	}
289	else if(player_state == PLAY)	291	else if(player_state == PLAY)
290	{	292	{
291	win->panel.play_btn->img_default = res_play_btn;	293	win->panel.play_btn->img_default = res_play_btn;
292	win->panel.play_btn->img_hilite = res_play_btn;	294	win->panel.play_btn->img_hilite = res_play_btn;
293	win->panel.play_btn->img_pressed = res_play_btn_pressed;	295	win->panel.play_btn->img_pressed = res_play_btn_pressed;
294	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);	296	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
295	player_state = PAUSE;	297	player_state = PAUSE;
296	sound_state = PLAY_2_PAUSE;	298	sound_state = PLAY_2_PAUSE;
297	}	299	}
298	break;	300	break;
299		301
300	case MSG_COMMAND:	302	case MSG_COMMAND:
301	switch((short)arg1)	303	switch((short)arg1)
302	{	304	{
303	case ID_PLAY:	305	case ID_PLAY:
304	if(player_state == PAUSE)	306	if(player_state == PAUSE)
305	{	307	{
306	win->panel.play_btn->img_default = res_pause_btn;	308	win->panel.play_btn->img_default = res_pause_btn;
307	win->panel.play_btn->img_hilite = res_pause_btn;	309	win->panel.play_btn->img_hilite = res_pause_btn;
308	win->panel.play_btn->img_pressed = res_pause_btn_pressed;	310	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
309	player_state = PLAY;	311	player_state = PLAY;
310	sound_state = PAUSE_2_PLAY;	312	sound_state = PAUSE_2_PLAY;
311	}	313	}
312	else if(player_state == PLAY)	314	else if(player_state == PLAY)
313	{	315	{
314	win->panel.play_btn->img_default = res_play_btn;	316	win->panel.play_btn->img_default = res_play_btn;
315	win->panel.play_btn->img_hilite = res_play_btn;	317	win->panel.play_btn->img_hilite = res_play_btn;
316	win->panel.play_btn->img_pressed = res_play_btn_pressed;	318	win->panel.play_btn->img_pressed = res_play_btn_pressed;
317	player_state = PAUSE;	319	player_state = PAUSE;
318	sound_state = PLAY_2_PAUSE;	320	sound_state = PLAY_2_PAUSE;
319	}	321	}
320	else if(player_state == STOP)	322	else if(player_state == STOP)
321	{	323	{
322	win->panel.play_btn->img_default = res_pause_btn;	324	win->panel.play_btn->img_default = res_pause_btn;
323	win->panel.play_btn->img_hilite = res_pause_btn;	325	win->panel.play_btn->img_hilite = res_pause_btn;
324	win->panel.play_btn->img_pressed = res_pause_btn_pressed;	326	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
325	rewind_pos = 0;	327	rewind_pos = 0;
326	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);	328	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
327	player_state = PLAY;	329	player_state = PLAY;
328	decoder_state = PREPARE;	330	decoder_state = PREPARE;
329	}	331	}
330	break;	332	break;
331		333
332	case ID_STOP:	334	case ID_STOP:
333	player_stop();	335	player_stop();
334	break;	336	break;
335		337
336	case ID_PROGRESS:	338	case ID_PROGRESS:
337	if(player_state != REWIND)	339	if(player_state != REWIND)
338	{	340	{
339	progress_t prg = (progress_t)arg2;	341	progress_t prg = (progress_t)arg2;
340		342
341	rewind_pos = (prg->max - prg->min)*prg->pos/prg->ctrl.w;	343	rewind_pos = (prg->max - prg->min)*prg->pos/prg->ctrl.w;
342		344
343	player_state = REWIND;	345	player_state = REWIND;
344	decoder_state = REWIND;	346	decoder_state = REWIND;
345	sound_state = PLAY_2_STOP;	347	sound_state = PLAY_2_STOP;
346	if(rewind_pos < prg->current)	348	if(rewind_pos < prg->current)
347	{	349	{
348	prg->current = rewind_pos;	350	prg->current = rewind_pos;
349	rewind_pos = -rewind_pos;	351	rewind_pos = -rewind_pos;
350	}	352	}
351	else	353	else
352	prg->current = rewind_pos;	354	prg->current = rewind_pos;
353		355
354	win->panel.play_btn->img_default = res_pause_btn;	356	win->panel.play_btn->img_default = res_pause_btn;
355	win->panel.play_btn->img_hilite = res_pause_btn;	357	win->panel.play_btn->img_hilite = res_pause_btn;
356	win->panel.play_btn->img_pressed = res_pause_btn_pressed;	358	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
357	send_message(&prg->ctrl, MSG_PAINT, 0, 0);	359	send_message(&prg->ctrl, MSG_PAINT, 0, 0);
358	};	360	};
359	break;	361	break;
360		362
361	case ID_VOL_CTRL:	363	case ID_VOL_CTRL:
362	{	364	{
363	slider_t sld = (slider_t)arg2;	365	slider_t sld = (slider_t)arg2;
364	int peak;	366	int peak;
365	int level;	367	int level;
366		368
367	peak = sld->min + sld->pos * (sld->max - sld->min)/(96);	369	peak = sld->min + sld->pos * (sld->max - sld->min)/(96);
368	level = peak;	370	level = peak;
369		371
370	set_audio_volume(level, level);	372	set_audio_volume(level, level);
371	send_message(&sld->ctrl, MSG_PAINT, 0, 0);	373	send_message(&sld->ctrl, MSG_PAINT, 0, 0);
372	win->panel.lvl->vol = level;	374	win->panel.lvl->vol = level;
373	}	375	}
374		376
375	default:	377	default:
376	break;	378	break;
377	}	379	}
378	break;	380	break;
379		381
380	default:	382	default:
381	def_window_proc(ctrl,msg,arg1,arg2);	383	def_window_proc(ctrl,msg,arg1,arg2);
382	};	384	};
383	return 0;	385	return 0;
384	};	386	};
385		387
386	#define VERSION_A 1	388	#define VERSION_A 1
387		389
388	extern queue_t q_video;	-
389	extern queue_t q_audio;	-
390		-
391	void render_time(render_t *render)	390	void render_time(render_t *render)
392	{	391	{
393	progress_t *prg = main_render->win->panel.prg;	392	progress_t *prg = main_render->win->panel.prg;
394	level_t *lvl = main_render->win->panel.lvl;	393	level_t *lvl = main_render->win->panel.lvl;
395		394
396	double ctime; /* milliseconds */	395	double ctime; /* milliseconds */
397	double fdelay; /* milliseconds */	396	double fdelay; /* milliseconds */
398		397
399	//again:	398	//again:
400		399
401	if(player_state == CLOSED)	400	if(player_state == CLOSED)
402	{	401	{
403	render->win->win_command = WIN_CLOSED;	402	render->win->win_command = WIN_CLOSED;
404	return;	403	return;
405	}	404	}
406	else if((player_state == PAUSE) \|\| (player_state == REWIND))	405	else if((player_state == PAUSE) \|\| (player_state == REWIND))
407	{	406	{
408	delay(1);	407	delay(1);
409	return;	408	return;
410	}	409	}
411	else if (decoder_state == STOP && frames_count == 0 &&	410	else if (decoder_state == STOP && frames_count == 0 &&
412	player_state != STOP)	411	player_state != STOP)
413	{	412	{
414	player_stop();	413	player_stop();
415	}	414	}
416	else if(player_state != PLAY)	415	else if(player_state != PLAY)
417	{	416	{
418	delay(1);	417	delay(1);
419	return;	418	return;
420	};	419	};
421		420
422		421
423	#ifdef VERSION_A	422	#ifdef VERSION_A
424	if(frames[vfx].ready == 1 )	423	if(frames[vfx].ready == 1 )
425	{	424	{
426	int sys_time;	425	int sys_time;
427		426
428	ctime = get_master_clock();	427	ctime = get_master_clock();
429	fdelay = (frames[vfx].pts - ctime);	428	fdelay = (frames[vfx].pts - ctime);
430		429
431	// printf("pts %f time %f delay %f\n",	430	// printf("pts %f time %f delay %f\n",
432	// frames[vfx].pts, ctime, fdelay);	431	// frames[vfx].pts, ctime, fdelay);
433		432
434	if(fdelay > 15.0)	433	if(fdelay > 15.0)
435	{	434	{
436	delay((int)fdelay/10);	435	delay((int)fdelay/10);
437	// return;	436	// return;
438	};	437	};
439	#if 0	438	#if 0
440	ctime = get_master_clock();	439	ctime = get_master_clock();
441	fdelay = (frames[vfx].pts - ctime);	440	fdelay = (frames[vfx].pts - ctime);
442		441
443	// while(fdelay > 0)	442	// while(fdelay > 0)
444	// {	443	// {
445	// yield();	444	// yield();
446	// ctime = get_master_clock();	445	// ctime = get_master_clock();
447	// fdelay = (frames[vfx].pts - ctime);	446	// fdelay = (frames[vfx].pts - ctime);
448	// }	447	// }
449		448
450	// sys_time = get_tick_count();	449	// sys_time = get_tick_count();
451		450
452	// if(fdelay < 0)	451	// if(fdelay < 0)
453	// printf("systime %d pts %f time %f delay %f\n",	452	// printf("systime %d pts %f time %f delay %f\n",
454	// sys_time*10, frames[vfx].pts, ctime, fdelay);	453	// sys_time*10, frames[vfx].pts, ctime, fdelay);
455		454
456	printf("pts %f time %f delay %f\n",	455	printf("pts %f time %f delay %f\n",
457	frames[vfx].pts, ctime, fdelay);	456	frames[vfx].pts, ctime, fdelay);
458	printf("video cache %d audio cache %d\n", q_video.size/1024, q_audio.size/1024);	457	printf("video cache %d audio cache %d\n", q_video.size/1024, q_audio.size/1024);
459	#endif	458	#endif
460		459
461	main_render->draw(main_render, &frames[vfx].picture);	460	main_render->draw(main_render, &frames[vfx].picture);
462	if(main_render->win->win_state != FULLSCREEN)	461	if(main_render->win->win_state != FULLSCREEN)
463	{	462	{
464	prg->current = frames[vfx].pts*1000;	463	prg->current = frames[vfx].pts*1000;
465	// printf("current %f\n", prg->current);	464	// printf("current %f\n", prg->current);
466	lvl->current = vfx & 1 ? sound_level_1 : sound_level_0;	465	lvl->current = vfx & 1 ? sound_level_1 : sound_level_0;
467		466
468	send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);	467	send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);
469		468
470	if(main_render->win->panel.layout)	469	if(main_render->win->panel.layout)
471	send_message(&lvl->ctrl, MSG_PAINT, 0, 0);	470	send_message(&lvl->ctrl, MSG_PAINT, 0, 0);
472	}	471	}
473		472
474	frames_count--;	473	frames_count--;
475	frames[vfx].ready = 0;	474	frames[vfx].ready = 0;
476	vfx++;	475	vfx++;
477	vfx&= 3;	476	vfx&= 3;
478	}	477	}
479	else delay(1);	478	else delay(1);
480		479
481	#else	480	#else
482		481
483	if(frames[vfx].ready == 1 )	482	if(frames[vfx].ready == 1 )
484	{	483	{
485	ctime = get_master_clock();	484	ctime = get_master_clock();
486	fdelay = (frames[vfx].pts - ctime);	485	fdelay = (frames[vfx].pts - ctime);
487		486
488	// printf("pts %f time %f delay %f\n",	487	// printf("pts %f time %f delay %f\n",
489	// frames[vfx].pts, ctime, fdelay);	488	// frames[vfx].pts, ctime, fdelay);
490		489
491	if(fdelay < 0.0 )	490	if(fdelay < 0.0 )
492	{	491	{
493	int next_vfx;	492	int next_vfx;
494	fdelay = 0;	493	fdelay = 0;
495	next_vfx = (vfx+1) & 3;	494	next_vfx = (vfx+1) & 3;
496	if( frames[next_vfx].ready == 1 )	495	if( frames[next_vfx].ready == 1 )

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/video.c – Rev 6106 → 6117