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

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/video.c – Rev 5372 → 5592