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


#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
#include "winlib/winlib.h"
#include "fplay.h"
 
extern int res_pause_btn[];
extern int res_pause_btn_pressed[];
 
extern int res_play_btn[];
extern int res_play_btn_pressed[];
 
extern int64_t stream_duration;
extern volatile int sound_level_0;
extern volatile int sound_level_1;
 
volatile int frames_count = 0;
 
struct SwsContext *cvt_ctx = NULL;
 
 
render_t   *main_render;
 
AVRational video_time_base;
AVFrame  *Frame;
 
void get_client_rect(rect_t *rc);
void run_render(window_t *win, void *render);
void window_update_layout(window_t *win);
int  fini_winlib();
 
void flush_video(vst_t *vst)
{
    vframe_t *vframe, *tmp;
 
    mutex_lock(&vst->output_lock);
    mutex_lock(&vst->input_lock);
 
    list_for_each_entry_safe(vframe, tmp, &vst->output_list, list)
        list_move_tail(&vframe->list, &vst->input_list);
 
    list_for_each_entry(vframe, &vst->output_list, list)
    {
        vframe->pts   = 0;
        vframe->ready = 0;
    }
 
    mutex_unlock(&vst->input_lock);
    mutex_unlock(&vst->output_lock);
 
    frames_count = 0;
};
 
int init_video(vst_t *vst)
{
    Frame = av_frame_alloc();
    if ( Frame == NULL )
    {
        printf("Cannot alloc video frame\n\r");
        return 0;
    };
 
    mutex_lock(&vst->decoder_lock);
 
    create_thread(video_thread, vst, 1024*1024);
 
    return 1;
};
 
static double  dts = 0.0;
 
static vframe_t *get_input_frame(vst_t *vst)
{
 
 
    vframe_t *vframe = NULL;
 
 
 
    mutex_lock(&vst->input_lock);
    if(!list_empty(&vst->input_list))
    {
        vframe = list_first_entry(&vst->input_list, vframe_t, list);
        list_del(&vframe->list);
 
 
    }
    mutex_unlock(&vst->input_lock);
 
    return vframe;
}
 
static void put_output_frame(vst_t *vst, vframe_t *vframe)
{
    mutex_lock(&vst->output_lock);
    if(list_empty(&vst->output_list))
        list_add_tail(&vframe->list, &vst->output_list);
    else
    {
        vframe_t *cur;
 
        cur = list_first_entry(&vst->output_list,vframe_t,list);
        if(vframe->pts < cur->pts)
            list_add_tail(&vframe->list, &vst->output_list);
        else
        {
            list_for_each_entry_reverse(cur,&vst->output_list,list)
            {
                if(vframe->pts > cur->pts)
                {
                    list_add(&vframe->list, &cur->list);
                    break;
                };
            };
        };
    };
    mutex_unlock(&vst->output_lock);
};
 
int decode_video(vst_t* vst)
{
    AVPacket   pkt;
    double     pts;
    int frameFinished;
 
    if(vst->decoder_frame == NULL)
        vst->decoder_frame = get_input_frame(vst);
 
    if(vst->decoder_frame == NULL)
        return 0;
 
 
    if( get_packet(&vst->q_video, &pkt) == 0 )
        return 0;
 
    frameFinished = 0;
    if(dts == 0)
        dts = pkt.pts;
 
    mutex_lock(&vst->gpu_lock);
 
    if(avcodec_decode_video2(vst->vCtx, Frame, &frameFinished, &pkt) <= 0)
        printf("video decoder error\n");
 
    if(frameFinished)
    {
        vframe_t  *vframe = vst->decoder_frame;;
        AVPicture *dst_pic;
 
        if(vst->hwdec)
            pts = pkt.pts;
        else
            pts = av_frame_get_best_effort_timestamp(Frame);
 
        pts*= av_q2d(video_time_base);
 
 
        dst_pic = &vframe->picture;
 
        if(vframe->is_hw_pic == 0)
            av_image_copy(dst_pic->data, dst_pic->linesize,
                          (const uint8_t**)Frame->data,
                          Frame->linesize, vst->vCtx->pix_fmt, vst->vCtx->width, vst->vCtx->height);
        else
            va_create_planar(vst, vframe);
 
        vframe->pts = pts*1000.0;
        vframe->pkt_pts = pkt.pts*av_q2d(video_time_base)*1000.0;
        vframe->pkt_dts = dts*av_q2d(video_time_base)*1000.0;
        vframe->ready = 1;
 
 
        put_output_frame(vst, vframe);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//        printf("decoded index: %d pts: %f pkt_pts %f pkt_dts %f\n",
//               vst->dfx, vst->vframe[vst->dfx].pts,
//               vst->vframe[vst->dfx].pkt_pts, vst->vframe[vst->dfx].pkt_dts);
 
        vst->decoder_frame = NULL;
        frames_count++;
        dts = 0;
    };
    av_frame_unref(Frame);
    mutex_unlock(&vst->gpu_lock);
 
    av_free_packet(&pkt);
 
    return 1;
}
 
extern volatile enum player_state player_state;
extern volatile enum player_state decoder_state;
extern volatile enum player_state sound_state;
 
extern int64_t rewind_pos;
 
static void player_stop()
{
    window_t  *win;
 
    win = main_render->win;
 
    rewind_pos = 0;
 
    win->panel.play_btn->img_default    = res_play_btn;
    win->panel.play_btn->img_hilite     = res_play_btn;
    win->panel.play_btn->img_pressed    = res_play_btn_pressed;
    win->panel.prg->current             = rewind_pos;
 
    send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
    player_state = STOP;
    decoder_state = PLAY_2_STOP;
    sound_state = PLAY_2_STOP;
    render_draw_client(main_render);
};
 
int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
{
    window_t  *win = (window_t*)ctrl;
    static int spc_down = 0;
    static int ent_down = 0;
 
    switch(msg)
    {
        case MSG_SIZE:
            if(main_render)
            {
                render_adjust_size(main_render, win);
                render_draw_client(main_render);
            };
            break;
 
        case MSG_KEY:
            switch((short)arg2)
            {
                case 0x39:
                    if(spc_down == 0)
                    {
                        spc_down = 1;
                        send_message(win, MSG_LBTNDOWN, 0, 0);
                    }
                    break;
 
                case 0xB9:
                    spc_down = 0;
                    break;
 
                case 0x1C:
                    if(ent_down == 0)
                    {
                        int screensize;
                        if(win->win_state == NORMAL)
                        {
                            win->saved = win->rc;
                            win->saved_state = win->win_state;
 
                            screensize = GetScreenSize();
                            __asm__ __volatile__(
                            "int $0x40"
                            ::"a"(67), "b"(0), "c"(0),
                            "d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );
                            win->win_state = FULLSCREEN;
                            window_update_layout(win);
                        }
                        else if(win->win_state == FULLSCREEN)
                        {
                            __asm__ __volatile__(
                            "int $0x40"
                            ::"a"(67), "b"(win->saved.l), "c"(win->saved.t),
                            "d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));
                            win->win_state = win->saved_state;
                            window_update_layout(win);
//                            if(win->saved_state == MAXIMIZED)
//                            {
//                                blit_caption(&win->caption);
//                                blit_panel(&win->panel);
//                            }
                        }
                        ent_down = 1;
                    };
                    break;
 
                case 0x9C:
                    ent_down = 0;
                    break;
            };
 
        case MSG_DRAW_CLIENT:
            if(main_render)
            {
                render_draw_client(main_render);
            };
            break;
 
        case MSG_LBTNDOWN:
 
            if(player_state == PAUSE)
            {
                win->panel.play_btn->img_default = res_pause_btn;
                win->panel.play_btn->img_hilite  = res_pause_btn;
                win->panel.play_btn->img_pressed = res_pause_btn_pressed;
                send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
                player_state = PLAY;
                sound_state  = PAUSE_2_PLAY;
 
            }
            else if(player_state == PLAY)
            {
                win->panel.play_btn->img_default = res_play_btn;
                win->panel.play_btn->img_hilite  = res_play_btn;
                win->panel.play_btn->img_pressed = res_play_btn_pressed;
                send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
                player_state = PAUSE;
                sound_state  = PLAY_2_PAUSE;
            }
            break;
 
        case MSG_COMMAND:
            switch((short)arg1)
            {
                case ID_PLAY:
                    if(player_state == PAUSE)
                    {
                        win->panel.play_btn->img_default  = res_pause_btn;
                        win->panel.play_btn->img_hilite   = res_pause_btn;
                        win->panel.play_btn->img_pressed = res_pause_btn_pressed;
                        player_state = PLAY;
                        sound_state = PAUSE_2_PLAY;
                    }
                    else if(player_state == PLAY)
                    {
                        win->panel.play_btn->img_default = res_play_btn;
                        win->panel.play_btn->img_hilite  = res_play_btn;
                        win->panel.play_btn->img_pressed  = res_play_btn_pressed;
                        player_state = PAUSE;
                        sound_state  = PLAY_2_PAUSE;
                    }
                    else if(player_state == STOP)
                    {
                        win->panel.play_btn->img_default  = res_pause_btn;
                        win->panel.play_btn->img_hilite   = res_pause_btn;
                        win->panel.play_btn->img_pressed = res_pause_btn_pressed;
                        rewind_pos = 0;
                        send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
                        player_state = PLAY;
                        decoder_state = PREPARE;
                    }
                    break;
 
                case ID_STOP:
                    player_stop();
                    break;
 
                case ID_PROGRESS:
                    if(player_state != REWIND)
                    {
                        progress_t *prg = (progress_t*)arg2;
 
                        rewind_pos = (prg->max - prg->min)*prg->pos/prg->ctrl.w;
 
                        player_state  = REWIND;
                        decoder_state = REWIND;
                        sound_state   = PLAY_2_STOP;
                        if(rewind_pos < prg->current)
                        {
                            prg->current  = rewind_pos;
                            rewind_pos = -rewind_pos;
                        }
                        else
                            prg->current  = rewind_pos;
 
                        win->panel.play_btn->img_default  = res_pause_btn;
                        win->panel.play_btn->img_hilite   = res_pause_btn;
                        win->panel.play_btn->img_pressed  = res_pause_btn_pressed;
                        send_message(&prg->ctrl, MSG_PAINT, 0, 0);
                    };
                    break;
 
                case ID_VOL_CTRL:
                {
                    slider_t *sld = (slider_t*)arg2;
                    int      peak;
                    int      level;
 
                    peak = sld->min + sld->pos * (sld->max - sld->min)/(96);
                    level =  peak;
 
                    set_audio_volume(level, level);
                    send_message(&sld->ctrl, MSG_PAINT, 0, 0);
                    win->panel.lvl->vol = level;
                }
 
                default:
                    break;
            }
            break;
 
        default:
            def_window_proc(ctrl,msg,arg1,arg2);
    };
    return 0;
};
 
void render_time(render_t *render)
{
    progress_t *prg = main_render->win->panel.prg;
    level_t    *lvl = main_render->win->panel.lvl;
    vst_t      *vst = main_render->vst;
    double      ctime;            /*    milliseconds    */
    double      fdelay;           /*    milliseconds    */
 
    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;
    };
 
    mutex_lock(&vst->output_lock);
    if(list_empty(&vst->output_list))
    {
        mutex_unlock(&vst->output_lock);
        delay(1);
    }
    else
    {
        vframe_t *vframe;
        int sys_time;
 
        vframe = list_first_entry(&vst->output_list, vframe_t, list);
        list_del(&vframe->list);
        mutex_unlock(&vst->output_lock);
 
        ctime = get_master_clock();
        fdelay = (vframe->pkt_pts - ctime);
 
        if(fdelay > 15.0)
        {
            delay((int)fdelay/10);
        };
 
//        printf("output index: %d pts: %f pkt_pts %f pkt_dts %f\n",
//               vframe->index,vframe->pts,vframe->pkt_pts,vframe->pkt_dts);
 
        main_render->draw(main_render, vframe);
 
        if(main_render->win->win_state != FULLSCREEN)
        {
            prg->current = vframe->pkt_pts * 1000;
            lvl->current = vframe->index & 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--;
        vframe->ready = 0;
 
        mutex_lock(&vst->input_lock);
        list_add_tail(&vframe->list, &vst->input_list);
        mutex_unlock(&vst->input_lock);
    }
}
 
 
extern char *movie_file;
 
int video_thread(void *param)
{
    vst_t *vst = param;
    window_t  *MainWindow;
 
    init_winlib();
 
    MainWindow = create_window(movie_file,0,
                               10,10,vst->vCtx->width,vst->vCtx->height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
 
    MainWindow->panel.prg->max = stream_duration;
 
    show_window(MainWindow, NORMAL);
 
    main_render = create_render(vst, MainWindow, HW_TEX_BLIT|HW_BIT_BLIT);
    if( main_render == NULL)
    {
        mutex_unlock(&vst->decoder_lock);
        printf("Cannot create render\n\r");
        return 0;
    };
 
    __sync_or_and_fetch(&threads_running,VIDEO_THREAD);
 
    render_draw_client(main_render);
    player_state = PLAY;
 
    mutex_unlock(&vst->decoder_lock);
 
    run_render(MainWindow, main_render);
 
    __sync_and_and_fetch(&threads_running,~VIDEO_THREAD);
 
    destroy_render(main_render);
    fini_winlib();
    player_state = CLOSED;
    return 0;
};
 
 
void draw_hw_picture(render_t *render, vframe_t *vframe);
void draw_sw_picture(render_t *render, vframe_t *vframe);
 
render_t *create_render(vst_t *vst, window_t *win, uint32_t flags)
{
    render_t *render;
 
    uint32_t right, bottom, draw_w, draw_h;
    uint32_t s, sw, sh;
    uint8_t  state;
 
//    __asm__ __volatile__("int3");
 
    render = (render_t*)malloc(sizeof(render_t));
    memset(render, 0, sizeof(render_t));
 
    render->vst = vst;
    render->win = win;
 
    render->ctx_width  = vst->vCtx->width;
    render->ctx_height = vst->vCtx->height;
    render->ctx_format = vst->vCtx->pix_fmt;
 
    render->caps = pxInit(1);
 
    right  = win->w;
    bottom = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
 
    printf("window width %d height %d\n",
                    right, bottom);
 
    render->win_state  = win->win_state;
 
    draw_w = bottom*render->ctx_width/render->ctx_height;
    draw_h = right*render->ctx_height/render->ctx_width;
 
    if(draw_w > right)
    {
        draw_w = right;
        draw_h = right*render->ctx_height/render->ctx_width;
    };
 
    if(draw_h > bottom)
    {
        draw_h = bottom;
        draw_w = bottom*render->ctx_width/render->ctx_height;
    };
 
    render->win_width  = win->w;
    render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
 
    render_set_size(render, draw_w, draw_h);
 
    pxCreateClient(0, CAPTION_HEIGHT, right, bottom);
 
    if(render->caps==0)
    {
        render->bitmap[0] = pxCreateBitmap(draw_w, draw_h);
        if(render->bitmap[0] == NULL)
        {
            free(render);
            return NULL;
        }
        render->draw = draw_sw_picture;
    }
    else
    {
        int width, height;
        int i;
 
        if(render->caps & HW_TEX_BLIT)
        {
            width  = render->ctx_width;
            height = render->ctx_height;
        }
        else
        {
            width  = draw_w;
            height = draw_h;;
        }
 
        for( i=0; i < 2; i++)
        {
            render->bitmap[i] = pxCreateBitmap(width, height);
            if( render->bitmap[i] == NULL )
            {
                player_state = CLOSED;
                free(render);
                return NULL;
            };
        }
 
        render->state = INIT;
        render->target = 0;
        render->draw   = draw_hw_picture;
    };
 
    printf("FPlay %s render engine: context %dx%d picture %dx%d\n",
           render->caps & HW_TEX_BLIT ? "hw_tex_blit":
           render->caps & HW_BIT_BLIT ? "hw_bit_blit":"software",
           render->ctx_width, render->ctx_height,
           draw_w, draw_h);
 
    return render;
};
 
void destroy_render(render_t *render)
{
 
    pxDestroyBitmap(render->bitmap[0]);
 
    if(render->caps & (HW_BIT_BLIT|HW_TEX_BLIT))          /* hw blitter */
        pxDestroyBitmap(render->bitmap[1]);
 
    pxFini();
};
 
void render_set_size(render_t *render, int width, int height)
{
    int i;
 
    render->layout = 0;
    render->rcvideo.l = 0;
    render->rcvideo.t = 0;
    render->rcvideo.r = width;
    render->rcvideo.b = height;
 
//    printf("render width %d height %d\n",width, height);
 
    if( render->win_height > height )
    {
        int yoffs;
        yoffs = (render->win_height-height)/2;
        if(yoffs)
        {
            render->rctop.t = 0;
            render->rctop.b = yoffs;
            render->rcvideo.t  = yoffs;
            render->layout |= HAS_TOP;
        }
 
        yoffs = render->win_height-(render->rcvideo.t+render->rcvideo.b);
        if(yoffs)
        {
            render->rcbottom.t = render->rcvideo.t+render->rcvideo.b;
            render->rcbottom.b = yoffs;
            render->layout |= HAS_BOTTOM;
        }
    }
 
    if( render->win_width > width )
    {
        int xoffs;
        xoffs = (render->win_width-width)/2;
        if(xoffs)
        {
            render->rcleft.r  = xoffs;
            render->rcvideo.l = xoffs;
            render->layout |= HAS_LEFT;
        }
        xoffs = render->win_width-(render->rcvideo.l+render->rcvideo.r);
        if(xoffs)
        {
            render->rcright.l = render->rcvideo.l+render->rcvideo.r;
            render->rcright.r = xoffs;
            render->layout |= HAS_RIGHT;
        }
    };
};
 
void render_adjust_size(render_t *render, window_t *win)
{
    uint32_t right, bottom, new_w, new_h;
    uint32_t s, sw, sh;
    uint8_t  state;
 
    right  = win->w;
    bottom = win->h;
 
    if(win->win_state != FULLSCREEN)
        bottom-= CAPTION_HEIGHT+PANEL_HEIGHT;
 
 //   printf("window width %d height %d\n",
 //                   right, bottom);
 
    render->win_state  = win->win_state;
 
    if(render->win_state == MINIMIZED)
        return;
 
    if(render->win_state == ROLLED)
        return;
 
    if( right  == render->win_width &&
        bottom == render->win_height)
        return;
 
//    printf("%s r: %d b: %d\n", __FUNCTION__, right, bottom);
 
    new_w = bottom*render->ctx_width/render->ctx_height;
    new_h = right*render->ctx_height/render->ctx_width;
 
    if(new_w > right)
    {
        new_w = right;
        new_h = right*render->ctx_height/render->ctx_width;
    };
    if(new_h > bottom)
    {
        new_h = bottom;
        new_w = bottom*render->ctx_width/render->ctx_height;
    };
 
    render->win_width  = right;
    render->win_height = bottom;
    render_set_size(render, new_w, new_h);
 
    if(render->caps & HW_TEX_BLIT)          /*  hw scaler  */
    {
        if(render->win->win_state == FULLSCREEN)
            pxResizeClient(render->rcvideo.l, render->rcvideo.t, new_w, new_h);
        else
            pxResizeClient(render->rcvideo.l, render->rcvideo.t+CAPTION_HEIGHT, new_w, new_h);
 
        return;
    };
 
    pxResizeBitmap(render->bitmap[0], new_w, new_h);
 
    if(render->caps & HW_BIT_BLIT)          /* hw blitter */
        pxResizeBitmap(render->bitmap[1], new_w, new_h);
 
    return;
};
 
static void render_hw_planar(render_t *render, vframe_t *vframe)
{
    vst_t *vst = render->vst;
    planar_t *planar = vframe->planar;
 
    if(vframe->is_hw_pic != 0 && vframe->format != AV_PIX_FMT_NONE)
    {
        mutex_lock(&render->vst->gpu_lock);
 
        pxBlitPlanar(planar, render->rcvideo.l,
                    CAPTION_HEIGHT+render->rcvideo.t,
                    render->rcvideo.r, render->rcvideo.b,0,0);
        mutex_unlock(&render->vst->gpu_lock);
 
    }
};
 
void draw_hw_picture(render_t *render, vframe_t *vframe)
{
    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];
    enum AVPixelFormat format;
 
    vst_t *vst = render->vst;
 
    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;
    };
 
    if(vst->hwdec)
    {
        render_hw_planar(render, vframe);
        return;
    };
 
    picture = &vframe->picture;
 
    format = render->vst->hwdec == 0 ? render->ctx_format : AV_PIX_FMT_BGRA;
    cvt_ctx = sws_getCachedContext(cvt_ctx, render->ctx_width, render->ctx_height, format,
                                   dst_width, dst_height, AV_PIX_FMT_BGRA,
                                   SWS_FAST_BILINEAR, NULL, NULL, NULL);
    if(cvt_ctx == NULL)
    {
        printf("Cannot initialize the conversion context!\n");
        return ;
    };
 
    bitmap = render->bitmap[render->target];
 
    bitmap_data = pxLockBitmap(bitmap, &bitmap_pitch);
    if( bitmap_data == NULL)
    {
        printf("Cannot lock bitmap!\n");
        return ;
    }
 
    data[0] = bitmap_data;
    data[1] = bitmap_data+1;
    data[2] = bitmap_data+2;
    data[3] = bitmap_data+3;
 
    linesize[0] = bitmap_pitch;
    linesize[1] = bitmap_pitch;
    linesize[2] = bitmap_pitch;
    linesize[3] = bitmap_pitch;
 
    sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
              picture->linesize, 0, render->ctx_height, data, linesize);
//    printf("sws_scale\n");
 
    mutex_lock(&render->vst->gpu_lock);
 
    if(render->caps & HW_TEX_BLIT)
    {
 
        if(render->win->win_state == FULLSCREEN)
            pxBlitBitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
                 render->rcvideo.r, render->rcvideo.b,0,0);
        else
            pxBlitBitmap(bitmap, render->rcvideo.l,
                    CAPTION_HEIGHT+render->rcvideo.t,
                    render->rcvideo.r, render->rcvideo.b,0,0);
    }
    else
    {
        if(render->win->win_state == FULLSCREEN)
            pxBlitBitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
                    render->rcvideo.r, render->rcvideo.b, 0,0);
        else
            pxBlitBitmap(bitmap, render->rcvideo.l,
                    CAPTION_HEIGHT+render->rcvideo.t,
                    render->rcvideo.r, render->rcvideo.b, 0, 0);
    };
    mutex_unlock(&render->vst->gpu_lock);
 
    render->last_bitmap = bitmap;
    render->target++;
    render->target&= 1;
}
 
void draw_sw_picture(render_t *render, vframe_t *vframe)
{
    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;
 
    picture = &vframe->picture;
 
    cvt_ctx = sws_getCachedContext(cvt_ctx,
              render->ctx_width, render->ctx_height,
              render->ctx_format,
              render->rcvideo.r, render->rcvideo.b,
              AV_PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);
    if(cvt_ctx == NULL)
    {
        printf("Cannot initialize the conversion context!\n");
        return ;
    }
 
    bitmap_data = pxLockBitmap(render->bitmap[0],&bitmap_pitch);
 
    data[0] = bitmap_data;
    data[1] = bitmap_data+1;
    data[2] = bitmap_data+2;
    data[3] = bitmap_data+3;
 
    linesize[0] = bitmap_pitch;
    linesize[1] = bitmap_pitch;
    linesize[2] = bitmap_pitch;
    linesize[3] = bitmap_pitch;
 
     sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
              picture->linesize, 0, render->ctx_height, data, linesize);
 
    if(render->win->win_state == FULLSCREEN)
        pxBlitBitmap(render->bitmap[0],render->rcvideo.l,render->rcvideo.t,
                 render->rcvideo.r, render->rcvideo.b,0,0);
    else
        pxBlitBitmap(render->bitmap[0], render->rcvideo.l,
                 CAPTION_HEIGHT+render->rcvideo.t,
                 render->rcvideo.r, render->rcvideo.b,0,0);
 
    render->last_bitmap = render->bitmap[0];
}
 
void render_draw_client(render_t *render)
{
    vst_t *vst = render->vst;
    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(vst->vframe[vst->vfx].ready == 1 )
//            main_render->draw(main_render, &vst->vframe[vst->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 6133	Rev 6135
1	#include	1	#include
2	#include	2	#include
3	#include	3	#include
4	#include	4	#include
5	#include	5	#include
6	#include	6	#include
7	#include	7	#include
8	#include	8	#include
9		9
10	#include "winlib/winlib.h"	10	#include "winlib/winlib.h"
11	#include "fplay.h"	11	#include "fplay.h"
12		12
13	extern int res_pause_btn[];	13	extern int res_pause_btn[];
14	extern int res_pause_btn_pressed[];	14	extern int res_pause_btn_pressed[];
15		15
16	extern int res_play_btn[];	16	extern int res_play_btn[];
17	extern int res_play_btn_pressed[];	17	extern int res_play_btn_pressed[];
18		18
19	extern int64_t stream_duration;	19	extern int64_t stream_duration;
20	extern volatile int sound_level_0;	20	extern volatile int sound_level_0;
21	extern volatile int sound_level_1;	21	extern volatile int sound_level_1;
22		22
23	volatile int frames_count = 0;	23	volatile int frames_count = 0;
24		24
25	struct SwsContext *cvt_ctx = NULL;	25	struct SwsContext *cvt_ctx = NULL;
26		26
27		27
28	render_t *main_render;	28	render_t *main_render;
29		29
30	AVRational video_time_base;	30	AVRational video_time_base;
31	AVFrame *Frame;	31	AVFrame *Frame;
32		32
33	void get_client_rect(rect_t *rc);	33	void get_client_rect(rect_t *rc);
34	void run_render(window_t win, void render);	34	void run_render(window_t win, void render);
35	void window_update_layout(window_t *win);	35	void window_update_layout(window_t *win);
36	int fini_winlib();	36	int fini_winlib();
37		37
38	void flush_video(vst_t *vst)	38	void flush_video(vst_t *vst)
39	{	39	{
40	vframe_t vframe, tmp;	40	vframe_t vframe, tmp;
41		41
42	mutex_lock(&vst->output_lock);	42	mutex_lock(&vst->output_lock);
43	mutex_lock(&vst->input_lock);	43	mutex_lock(&vst->input_lock);
44		44
45	list_for_each_entry_safe(vframe, tmp, &vst->output_list, list)	45	list_for_each_entry_safe(vframe, tmp, &vst->output_list, list)
46	list_move_tail(&vframe->list, &vst->input_list);	46	list_move_tail(&vframe->list, &vst->input_list);
47		47
48	list_for_each_entry(vframe, &vst->output_list, list)	48	list_for_each_entry(vframe, &vst->output_list, list)
49	{	49	{
50	vframe->pts = 0;	50	vframe->pts = 0;
51	vframe->ready = 0;	51	vframe->ready = 0;
52	}	52	}
53		53
54	mutex_unlock(&vst->input_lock);	54	mutex_unlock(&vst->input_lock);
55	mutex_unlock(&vst->output_lock);	55	mutex_unlock(&vst->output_lock);
56		56
57	frames_count = 0;	57	frames_count = 0;
58	};	58	};
59		59
60	int init_video(vst_t *vst)	60	int init_video(vst_t *vst)
61	{	61	{
62	Frame = av_frame_alloc();	62	Frame = av_frame_alloc();
63	if ( Frame == NULL )	63	if ( Frame == NULL )
64	{	64	{
65	printf("Cannot alloc video frame\n\r");	65	printf("Cannot alloc video frame\n\r");
66	return 0;	66	return 0;
67	};	67	};
68		68
69	mutex_lock(&vst->decoder_lock);	69	mutex_lock(&vst->decoder_lock);
70		70
71	create_thread(video_thread, vst, 1024*1024);	71	create_thread(video_thread, vst, 1024*1024);
72		72
73	return 1;	73	return 1;
74	};	74	};
75		75
76	static double dts = 0.0;	76	static double dts = 0.0;
77		77
78	int decode_video(vst_t* vst)	78	static vframe_t get_input_frame(vst_t vst)
79	{	79	{
80	AVPacket pkt;	-
81	double pts;	-
82	int frameFinished;	80	vframe_t *vframe = NULL;
83		-
84	if(vst->decoder_frame == NULL)	-
85	{	81
86	mutex_lock(&vst->input_lock);	82	mutex_lock(&vst->input_lock);
87	if(list_empty(&vst->input_list))	83	if(!list_empty(&vst->input_list))
88	{	84	{
89	mutex_unlock(&vst->input_lock);	85	vframe = list_first_entry(&vst->input_list, vframe_t, list);
90	return -1;	86	list_del(&vframe->list);
91	}	-
92	vst->decoder_frame = list_first_entry(&vst->input_list, vframe_t, list);	-
93	list_del(&vst->decoder_frame->list);	87	}
-		88	mutex_unlock(&vst->input_lock);
-		89
-		90	return vframe;
-		91	}
-		92
-		93	static void put_output_frame(vst_t vst, vframe_t vframe)
-		94	{
94	mutex_unlock(&vst->input_lock);	95	mutex_lock(&vst->output_lock);
-		96	if(list_empty(&vst->output_list))
-		97	list_add_tail(&vframe->list, &vst->output_list);
-		98	else
-		99	{
-		100	vframe_t *cur;
-		101
-		102	cur = list_first_entry(&vst->output_list,vframe_t,list);
-		103	if(vframe->pts < cur->pts)
-		104	list_add_tail(&vframe->list, &vst->output_list);
-		105	else
-		106	{
-		107	list_for_each_entry_reverse(cur,&vst->output_list,list)
-		108	{
-		109	if(vframe->pts > cur->pts)
-		110	{
-		111	list_add(&vframe->list, &cur->list);
-		112	break;
-		113	};
-		114	};
-		115	};
95		116	};
96	vframe_t *vframe = vst->decoder_frame;	117	mutex_unlock(&vst->output_lock);
97	};	118	};
-		119
-		120	int decode_video(vst_t* vst)
-		121	{
-		122	AVPacket pkt;
-		123	double pts;
-		124	int frameFinished;
-		125
-		126	if(vst->decoder_frame == NULL)
-		127	vst->decoder_frame = get_input_frame(vst);
-		128
-		129	if(vst->decoder_frame == NULL)
98		130	return 0;
99	if( get_packet(&vst->q_video, &pkt) == 0 )	-
100	{	131
101	return 0;	132	if( get_packet(&vst->q_video, &pkt) == 0 )
102	};	133	return 0;
103		134
104	frameFinished = 0;	135	frameFinished = 0;
105	if(dts == 0)	136	if(dts == 0)
106	dts = pkt.pts;	137	dts = pkt.pts;
107		138
108	mutex_lock(&vst->gpu_lock);	139	mutex_lock(&vst->gpu_lock);
109		140
110	if(avcodec_decode_video2(vst->vCtx, Frame, &frameFinished, &pkt) <= 0)	141	if(avcodec_decode_video2(vst->vCtx, Frame, &frameFinished, &pkt) <= 0)
111	printf("video decoder error\n");	142	printf("video decoder error\n");
112		143
113	if(frameFinished)	144	if(frameFinished)
114	{	145	{
115	vframe_t *vframe;	146	vframe_t *vframe = vst->decoder_frame;;
116	AVPicture *dst_pic;	147	AVPicture *dst_pic;
117		148
-		149	if(vst->hwdec)
-		150	pts = pkt.pts;
-		151	else
118	pts = av_frame_get_best_effort_timestamp(Frame);	152	pts = av_frame_get_best_effort_timestamp(Frame);
-		153
119	pts *= av_q2d(video_time_base);	154	pts*= av_q2d(video_time_base);
120		-
121	vframe = vst->decoder_frame;	155
122	dst_pic = &vframe->picture;	156	dst_pic = &vframe->picture;
123		157
124	if(vframe->is_hw_pic == 0)	158	if(vframe->is_hw_pic == 0)
125	av_image_copy(dst_pic->data, dst_pic->linesize,	159	av_image_copy(dst_pic->data, dst_pic->linesize,
126	(const uint8_t**)Frame->data,	160	(const uint8_t**)Frame->data,
127	Frame->linesize, vst->vCtx->pix_fmt, vst->vCtx->width, vst->vCtx->height);	161	Frame->linesize, vst->vCtx->pix_fmt, vst->vCtx->width, vst->vCtx->height);
128	else	162	else
129	va_create_planar(vst, vframe);	163	va_create_planar(vst, vframe);
130		164
131	vframe->pts = pts*1000.0;	165	vframe->pts = pts*1000.0;
132	vframe->pkt_pts = pkt.ptsav_q2d(video_time_base)1000.0;	166	vframe->pkt_pts = pkt.ptsav_q2d(video_time_base)1000.0;
133	vframe->pkt_dts = dtsav_q2d(video_time_base)1000.0;	167	vframe->pkt_dts = dtsav_q2d(video_time_base)1000.0;
134	vframe->ready = 1;	168	vframe->ready = 1;
135		169
136		-
137	mutex_lock(&vst->output_lock);	170	put_output_frame(vst, vframe);
138		-
139	if(list_empty(&vst->output_list))	-
140	list_add_tail(&vframe->list, &vst->output_list);	-
141	else	-
142	{	-
143	vframe_t *cur;	-
144		-
145	cur = list_first_entry(&vst->output_list,vframe_t,list);	-
146	if(vframe->pkt_pts < cur->pkt_pts)	-
147	{	-
148	list_add_tail(&vframe->list, &vst->output_list);	-
149	}	-
150	else	-
151	{	-
152	list_for_each_entry_reverse(cur,&vst->output_list,list)	-
153	{	-
154	if(vframe->pkt_pts > cur->pkt_pts)	-
155	{	-
156	list_add(&vframe->list, &cur->list);	-
157	break;	-
158	};	-
159	};	-
160	};	-
161	};	-
162	mutex_unlock(&vst->output_lock);	-
163		-
164		171
165	// printf("decoded index: %d pts: %f pkt_pts %f pkt_dts %f\n",	172	// printf("decoded index: %d pts: %f pkt_pts %f pkt_dts %f\n",
166	// vst->dfx, vst->vframe[vst->dfx].pts,	173	// vst->dfx, vst->vframe[vst->dfx].pts,
167	// vst->vframe[vst->dfx].pkt_pts, vst->vframe[vst->dfx].pkt_dts);	174	// vst->vframe[vst->dfx].pkt_pts, vst->vframe[vst->dfx].pkt_dts);
168		175
169	vst->decoder_frame = NULL;	176	vst->decoder_frame = NULL;
170	frames_count++;	177	frames_count++;
171	dts = 0;	178	dts = 0;
172	};	179	};
173	av_frame_unref(Frame);	180	av_frame_unref(Frame);
174	mutex_unlock(&vst->gpu_lock);	181	mutex_unlock(&vst->gpu_lock);
175		182
176	av_free_packet(&pkt);	183	av_free_packet(&pkt);
177		184
178	return 1;	185	return 1;
179	}	186	}
180		187
181	extern volatile enum player_state player_state;	188	extern volatile enum player_state player_state;
182	extern volatile enum player_state decoder_state;	189	extern volatile enum player_state decoder_state;
183	extern volatile enum player_state sound_state;	190	extern volatile enum player_state sound_state;
184		191
185	extern int64_t rewind_pos;	192	extern int64_t rewind_pos;
186		193
187	static void player_stop()	194	static void player_stop()
188	{	195	{
189	window_t *win;	196	window_t *win;
190		197
191	win = main_render->win;	198	win = main_render->win;
192		199
193	rewind_pos = 0;	200	rewind_pos = 0;
194		201
195	win->panel.play_btn->img_default = res_play_btn;	202	win->panel.play_btn->img_default = res_play_btn;
196	win->panel.play_btn->img_hilite = res_play_btn;	203	win->panel.play_btn->img_hilite = res_play_btn;
197	win->panel.play_btn->img_pressed = res_play_btn_pressed;	204	win->panel.play_btn->img_pressed = res_play_btn_pressed;
198	win->panel.prg->current = rewind_pos;	205	win->panel.prg->current = rewind_pos;
199		206
200	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);	207	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
201	player_state = STOP;	208	player_state = STOP;
202	decoder_state = PLAY_2_STOP;	209	decoder_state = PLAY_2_STOP;
203	sound_state = PLAY_2_STOP;	210	sound_state = PLAY_2_STOP;
204	render_draw_client(main_render);	211	render_draw_client(main_render);
205	};	212	};
206		213
207	int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)	214	int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
208	{	215	{
209	window_t win = (window_t)ctrl;	216	window_t win = (window_t)ctrl;
210	static int spc_down = 0;	217	static int spc_down = 0;
211	static int ent_down = 0;	218	static int ent_down = 0;
212		219
213	switch(msg)	220	switch(msg)
214	{	221	{
215	case MSG_SIZE:	222	case MSG_SIZE:
216	if(main_render)	223	if(main_render)
217	{	224	{
218	render_adjust_size(main_render, win);	225	render_adjust_size(main_render, win);
219	render_draw_client(main_render);	226	render_draw_client(main_render);
220	};	227	};
221	break;	228	break;
222		229
223	case MSG_KEY:	230	case MSG_KEY:
224	switch((short)arg2)	231	switch((short)arg2)
225	{	232	{
226	case 0x39:	233	case 0x39:
227	if(spc_down == 0)	234	if(spc_down == 0)
228	{	235	{
229	spc_down = 1;	236	spc_down = 1;
230	send_message(win, MSG_LBTNDOWN, 0, 0);	237	send_message(win, MSG_LBTNDOWN, 0, 0);
231	}	238	}
232	break;	239	break;
233		240
234	case 0xB9:	241	case 0xB9:
235	spc_down = 0;	242	spc_down = 0;
236	break;	243	break;
237		244
238	case 0x1C:	245	case 0x1C:
239	if(ent_down == 0)	246	if(ent_down == 0)
240	{	247	{
241	int screensize;	248	int screensize;
242	if(win->win_state == NORMAL)	249	if(win->win_state == NORMAL)
243	{	250	{
244	win->saved = win->rc;	251	win->saved = win->rc;
245	win->saved_state = win->win_state;	252	win->saved_state = win->win_state;
246		253
247	screensize = GetScreenSize();	254	screensize = GetScreenSize();
248	__asm__ __volatile__(	255	__asm__ __volatile__(
249	"int $0x40"	256	"int $0x40"
250	::"a"(67), "b"(0), "c"(0),	257	::"a"(67), "b"(0), "c"(0),
251	"d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );	258	"d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );
252	win->win_state = FULLSCREEN;	259	win->win_state = FULLSCREEN;
253	window_update_layout(win);	260	window_update_layout(win);
254	}	261	}
255	else if(win->win_state == FULLSCREEN)	262	else if(win->win_state == FULLSCREEN)
256	{	263	{
257	__asm__ __volatile__(	264	__asm__ __volatile__(
258	"int $0x40"	265	"int $0x40"
259	::"a"(67), "b"(win->saved.l), "c"(win->saved.t),	266	::"a"(67), "b"(win->saved.l), "c"(win->saved.t),
260	"d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));	267	"d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));
261	win->win_state = win->saved_state;	268	win->win_state = win->saved_state;
262	window_update_layout(win);	269	window_update_layout(win);
263	// if(win->saved_state == MAXIMIZED)	270	// if(win->saved_state == MAXIMIZED)
264	// {	271	// {
265	// blit_caption(&win->caption);	272	// blit_caption(&win->caption);
266	// blit_panel(&win->panel);	273	// blit_panel(&win->panel);
267	// }	274	// }
268	}	275	}
269	ent_down = 1;	276	ent_down = 1;
270	};	277	};
271	break;	278	break;
272		279
273	case 0x9C:	280	case 0x9C:
274	ent_down = 0;	281	ent_down = 0;
275	break;	282	break;
276	};	283	};
277		284
278	case MSG_DRAW_CLIENT:	285	case MSG_DRAW_CLIENT:
279	if(main_render)	286	if(main_render)
280	{	287	{
281	render_draw_client(main_render);	288	render_draw_client(main_render);
282	};	289	};
283	break;	290	break;
284		291
285	case MSG_LBTNDOWN:	292	case MSG_LBTNDOWN:
286		293
287	if(player_state == PAUSE)	294	if(player_state == PAUSE)
288	{	295	{
289	win->panel.play_btn->img_default = res_pause_btn;	296	win->panel.play_btn->img_default = res_pause_btn;
290	win->panel.play_btn->img_hilite = res_pause_btn;	297	win->panel.play_btn->img_hilite = res_pause_btn;
291	win->panel.play_btn->img_pressed = res_pause_btn_pressed;	298	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
292	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);	299	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
293	player_state = PLAY;	300	player_state = PLAY;
294	sound_state = PAUSE_2_PLAY;	301	sound_state = PAUSE_2_PLAY;
295		302
296	}	303	}
297	else if(player_state == PLAY)	304	else if(player_state == PLAY)
298	{	305	{
299	win->panel.play_btn->img_default = res_play_btn;	306	win->panel.play_btn->img_default = res_play_btn;
300	win->panel.play_btn->img_hilite = res_play_btn;	307	win->panel.play_btn->img_hilite = res_play_btn;
301	win->panel.play_btn->img_pressed = res_play_btn_pressed;	308	win->panel.play_btn->img_pressed = res_play_btn_pressed;
302	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);	309	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
303	player_state = PAUSE;	310	player_state = PAUSE;
304	sound_state = PLAY_2_PAUSE;	311	sound_state = PLAY_2_PAUSE;
305	}	312	}
306	break;	313	break;
307		314
308	case MSG_COMMAND:	315	case MSG_COMMAND:
309	switch((short)arg1)	316	switch((short)arg1)
310	{	317	{
311	case ID_PLAY:	318	case ID_PLAY:
312	if(player_state == PAUSE)	319	if(player_state == PAUSE)
313	{	320	{
314	win->panel.play_btn->img_default = res_pause_btn;	321	win->panel.play_btn->img_default = res_pause_btn;
315	win->panel.play_btn->img_hilite = res_pause_btn;	322	win->panel.play_btn->img_hilite = res_pause_btn;
316	win->panel.play_btn->img_pressed = res_pause_btn_pressed;	323	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
317	player_state = PLAY;	324	player_state = PLAY;
318	sound_state = PAUSE_2_PLAY;	325	sound_state = PAUSE_2_PLAY;
319	}	326	}
320	else if(player_state == PLAY)	327	else if(player_state == PLAY)
321	{	328	{
322	win->panel.play_btn->img_default = res_play_btn;	329	win->panel.play_btn->img_default = res_play_btn;
323	win->panel.play_btn->img_hilite = res_play_btn;	330	win->panel.play_btn->img_hilite = res_play_btn;
324	win->panel.play_btn->img_pressed = res_play_btn_pressed;	331	win->panel.play_btn->img_pressed = res_play_btn_pressed;
325	player_state = PAUSE;	332	player_state = PAUSE;
326	sound_state = PLAY_2_PAUSE;	333	sound_state = PLAY_2_PAUSE;
327	}	334	}
328	else if(player_state == STOP)	335	else if(player_state == STOP)
329	{	336	{
330	win->panel.play_btn->img_default = res_pause_btn;	337	win->panel.play_btn->img_default = res_pause_btn;
331	win->panel.play_btn->img_hilite = res_pause_btn;	338	win->panel.play_btn->img_hilite = res_pause_btn;
332	win->panel.play_btn->img_pressed = res_pause_btn_pressed;	339	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
333	rewind_pos = 0;	340	rewind_pos = 0;
334	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);	341	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
335	player_state = PLAY;	342	player_state = PLAY;
336	decoder_state = PREPARE;	343	decoder_state = PREPARE;
337	}	344	}
338	break;	345	break;
339		346
340	case ID_STOP:	347	case ID_STOP:
341	player_stop();	348	player_stop();
342	break;	349	break;
343		350
344	case ID_PROGRESS:	351	case ID_PROGRESS:
345	if(player_state != REWIND)	352	if(player_state != REWIND)
346	{	353	{
347	progress_t prg = (progress_t)arg2;	354	progress_t prg = (progress_t)arg2;
348		355
349	rewind_pos = (prg->max - prg->min)*prg->pos/prg->ctrl.w;	356	rewind_pos = (prg->max - prg->min)*prg->pos/prg->ctrl.w;
350		357
351	player_state = REWIND;	358	player_state = REWIND;
352	decoder_state = REWIND;	359	decoder_state = REWIND;
353	sound_state = PLAY_2_STOP;	360	sound_state = PLAY_2_STOP;
354	if(rewind_pos < prg->current)	361	if(rewind_pos < prg->current)
355	{	362	{
356	prg->current = rewind_pos;	363	prg->current = rewind_pos;
357	rewind_pos = -rewind_pos;	364	rewind_pos = -rewind_pos;
358	}	365	}
359	else	366	else
360	prg->current = rewind_pos;	367	prg->current = rewind_pos;
361		368
362	win->panel.play_btn->img_default = res_pause_btn;	369	win->panel.play_btn->img_default = res_pause_btn;
363	win->panel.play_btn->img_hilite = res_pause_btn;	370	win->panel.play_btn->img_hilite = res_pause_btn;
364	win->panel.play_btn->img_pressed = res_pause_btn_pressed;	371	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
365	send_message(&prg->ctrl, MSG_PAINT, 0, 0);	372	send_message(&prg->ctrl, MSG_PAINT, 0, 0);
366	};	373	};
367	break;	374	break;
368		375
369	case ID_VOL_CTRL:	376	case ID_VOL_CTRL:
370	{	377	{
371	slider_t sld = (slider_t)arg2;	378	slider_t sld = (slider_t)arg2;
372	int peak;	379	int peak;
373	int level;	380	int level;
374		381
375	peak = sld->min + sld->pos * (sld->max - sld->min)/(96);	382	peak = sld->min + sld->pos * (sld->max - sld->min)/(96);
376	level = peak;	383	level = peak;
377		384
378	set_audio_volume(level, level);	385	set_audio_volume(level, level);
379	send_message(&sld->ctrl, MSG_PAINT, 0, 0);	386	send_message(&sld->ctrl, MSG_PAINT, 0, 0);
380	win->panel.lvl->vol = level;	387	win->panel.lvl->vol = level;
381	}	388	}
382		389
383	default:	390	default:
384	break;	391	break;
385	}	392	}
386	break;	393	break;
387		394
388	default:	395	default:
389	def_window_proc(ctrl,msg,arg1,arg2);	396	def_window_proc(ctrl,msg,arg1,arg2);
390	};	397	};
391	return 0;	398	return 0;
392	};	399	};
393		400
394	void render_time(render_t *render)	401	void render_time(render_t *render)
395	{	402	{
396	progress_t *prg = main_render->win->panel.prg;	403	progress_t *prg = main_render->win->panel.prg;
397	level_t *lvl = main_render->win->panel.lvl;	404	level_t *lvl = main_render->win->panel.lvl;
398	vst_t *vst = main_render->vst;	405	vst_t *vst = main_render->vst;
399	double ctime; /* milliseconds */	406	double ctime; /* milliseconds */
400	double fdelay; /* milliseconds */	407	double fdelay; /* milliseconds */
401		408
402	if(player_state == CLOSED)	409	if(player_state == CLOSED)
403	{	410	{
404	render->win->win_command = WIN_CLOSED;	411	render->win->win_command = WIN_CLOSED;
405	return;	412	return;
406	}	413	}
407	else if((player_state == PAUSE) \|\| (player_state == REWIND))	414	else if((player_state == PAUSE) \|\| (player_state == REWIND))
408	{	415	{
409	delay(1);	416	delay(1);
410	return;	417	return;
411	}	418	}
412	else if (decoder_state == STOP && frames_count == 0 &&	419	else if (decoder_state == STOP && frames_count == 0 &&
413	player_state != STOP)	420	player_state != STOP)
414	{	421	{
415	player_stop();	422	player_stop();
416	}	423	}
417	else if(player_state != PLAY)	424	else if(player_state != PLAY)
418	{	425	{
419	delay(1);	426	delay(1);
420	return;	427	return;
421	};	428	};
422		429
423	mutex_lock(&vst->output_lock);	430	mutex_lock(&vst->output_lock);
424	if(list_empty(&vst->output_list))	431	if(list_empty(&vst->output_list))
425	{	432	{
426	mutex_unlock(&vst->output_lock);	433	mutex_unlock(&vst->output_lock);
427	delay(1);	434	delay(1);
428	}	435	}
429	else	436	else
430	{	437	{
431	vframe_t *vframe;	438	vframe_t *vframe;
432	int sys_time;	439	int sys_time;
433		440
434	vframe = list_first_entry(&vst->output_list, vframe_t, list);	441	vframe = list_first_entry(&vst->output_list, vframe_t, list);
435	list_del(&vframe->list);	442	list_del(&vframe->list);
436	mutex_unlock(&vst->output_lock);	443	mutex_unlock(&vst->output_lock);
437		444
438	ctime = get_master_clock();	445	ctime = get_master_clock();
439	fdelay = (vframe->pkt_pts - ctime);	446	fdelay = (vframe->pkt_pts - ctime);
440		447
441	if(fdelay > 15.0)	448	if(fdelay > 15.0)
442	{	449	{
443	delay((int)fdelay/10);	450	delay((int)fdelay/10);
444	};	451	};
445		452
446	// printf("output index: %d pts: %f pkt_pts %f pkt_dts %f\n",	453	// printf("output index: %d pts: %f pkt_pts %f pkt_dts %f\n",
447	// vframe->index,vframe->pts,vframe->pkt_pts,vframe->pkt_dts);	454	// vframe->index,vframe->pts,vframe->pkt_pts,vframe->pkt_dts);
448		455
449	main_render->draw(main_render, vframe);	456	main_render->draw(main_render, vframe);
450		457
451	if(main_render->win->win_state != FULLSCREEN)	458	if(main_render->win->win_state != FULLSCREEN)
452	{	459	{
453	prg->current = vframe->pkt_pts * 1000;	460	prg->current = vframe->pkt_pts * 1000;
454	lvl->current = vframe->index & 1 ? sound_level_1 : sound_level_0;	461	lvl->current = vframe->index & 1 ? sound_level_1 : sound_level_0;
455		462
456	send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);	463	send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);
457		464
458	if(main_render->win->panel.layout)	465	if(main_render->win->panel.layout)

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/video.c – Rev 6133 → 6135