WebSVN – Kolibri OS – Diff – /programs/media/Fplay/video.c


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

Subversion Repositories Kolibri OS

(root)/programs/media/Fplay/video.c @ 3748 – Rev 3292 → 3334