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

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/video.c – Rev 6136 → 6144