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


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

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/video.c – Rev 4438 → 5021