Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include "fplay.h"

extern int res_pause_btn_pressed[];

extern int res_play_btn_pressed[];

extern volatile int sound_level_0;

extern volatile int sound_level_1;

AVFrame  *Frame;

void run_render(window_t *win, void *render);

void window_update_layout(window_t *win);

int  fini_winlib();

{

    vframe_t *vframe, *tmp;

    mutex_lock(&vst->input_lock);

        list_move_tail(&vframe->list, &vst->input_list);

    {

        vframe->pts   = 0;

        vframe->ready = 0;

    }

    mutex_unlock(&vst->output_lock);

};

{

    Frame = av_frame_alloc();

    if ( Frame == NULL )

    {

        printf("Cannot alloc video frame\n\r");

        return 0;

    };

};

{

    vframe_t *vframe = NULL;

    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);

}

{

    mutex_lock(&vst->output_lock);

    if(list_empty(&vst->output_list))

        list_add_tail(&vframe->list, &vst->output_list);

    else

    {

        vframe_t *cur;

        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);

};

{

    AVPacket   pkt;

    double     pts;

    int frameFinished;

        vst->decoder_frame = get_input_frame(vst);

        return 0;

        return 0;

    if(dts == 0)

        dts = pkt.pts;

        printf("video decoder error\n");

    {

        vframe_t  *vframe = vst->decoder_frame;;

        AVPicture *dst_pic;

            pts = pkt.pts;

        else

            pts = av_frame_get_best_effort_timestamp(Frame);

            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->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;

//               vst->dfx, vst->vframe[vst->dfx].pts,

//               vst->vframe[vst->dfx].pkt_pts, vst->vframe[vst->dfx].pkt_dts);

        frames_count++;

        dts = 0;

    };

    av_frame_unref(Frame);

    mutex_unlock(&vst->gpu_lock);

}

extern volatile enum player_state decoder_state;

extern volatile enum player_state sound_state;

{

    window_t  *win;

    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;

    player_state = STOP;

    decoder_state = PLAY_2_STOP;

    sound_state = PLAY_2_STOP;

    render_draw_client(main_render);

};

{

    window_t  *win = (window_t*)ctrl;

    static int spc_down = 0;

    static int ent_down = 0;

    {

        case MSG_SIZE:

            if(main_render)

            {

                render_adjust_size(main_render, win);

                render_draw_client(main_render);

            };

            break;

            switch((short)arg2)

            {

                case 0x39:

                    if(spc_down == 0)

                    {

                        spc_down = 1;

                        send_message(win, MSG_LBTNDOWN, 0, 0);

                    }

                    break;

                    spc_down = 0;

                    break;

                    if(ent_down == 0)

                    {

                        int screensize;

                        if(win->win_state == NORMAL)

                        {

                            win->saved = win->rc;

                            win->saved_state = win->win_state;

                            __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;

                    ent_down = 0;

                    break;

            };

            if(main_render)

            {

                render_draw_client(main_render);

            };

            break;

            {

                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;

            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;

                    player_stop();

                    break;

                    if(player_state != REWIND)

                    {

                        progress_t *prg = (progress_t*)arg2;

                        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_hilite   = res_pause_btn;

                        win->panel.play_btn->img_pressed  = res_pause_btn_pressed;

                        send_message(&prg->ctrl, MSG_PAINT, 0, 0);

                    };

                    break;

                {

                    slider_t *sld = (slider_t*)arg2;

                    int      peak;

                    int      level;

                    level =  peak;

                    send_message(&sld->ctrl, MSG_PAINT, 0, 0);

                    win->panel.lvl->vol = level;

                }

                    break;

            }

            break;

            def_window_proc(ctrl,msg,arg1,arg2);

    };

    return 0;

};

{

    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    */

    {

        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;

    };

    if(list_empty(&vst->output_list))

    {

        mutex_unlock(&vst->output_lock);

        delay(1);

    }

    else

    {

        vframe_t *vframe;

        int sys_time;

        list_del(&vframe->list);

        mutex_unlock(&vst->output_lock);

        fdelay = (vframe->pkt_pts - ctime);

        {

            delay((int)fdelay/10);

        };

//               vframe->index,vframe->pts,vframe->pkt_pts,vframe->pkt_dts);

        {

            prg->current = vframe->pkt_pts * 1000;

            lvl->current = vframe->index & 1 ? sound_level_1 : sound_level_0;

                send_message(&lvl->ctrl, MSG_PAINT, 0, 0);

        }

        vframe->ready = 0;

        list_add_tail(&vframe->list, &vst->input_list);

        mutex_unlock(&vst->input_lock);

    }

}

{

    vst_t *vst = param;

    window_t  *MainWindow;

                               10,10,vst->vCtx->width,vst->vCtx->height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);

    if( main_render == NULL)

    {

        mutex_unlock(&vst->decoder_lock);

        printf("Cannot create render\n\r");

        return 0;

    };

    player_state = PLAY;

    fini_winlib();

    player_state = CLOSED;

    return 0;

};

void draw_sw_picture(render_t *render, vframe_t *vframe);

{

    render_t *render;

    uint32_t s, sw, sh;

    uint8_t  state;

    memset(render, 0, sizeof(render_t));

    render->win = win;

    render->ctx_height = vst->vCtx->height;

    render->ctx_format = vst->vCtx->pix_fmt;

    bottom = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;

                    right, bottom);

    draw_h = right*render->ctx_height/render->ctx_width;

    {

        draw_w = right;

        draw_h = right*render->ctx_height/render->ctx_width;

    };

    {

        draw_h = bottom;

        draw_w = bottom*render->ctx_width/render->ctx_height;

    };

    render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;

    {

        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;

        {

            width  = render->ctx_width;

            height = render->ctx_height;

        }

        else

        {

            width  = draw_w;

            height = draw_h;;

        }

        {

            render->bitmap[i] = pxCreateBitmap(width, height);

            if( render->bitmap[i] == NULL )

            {

                player_state = CLOSED;

                free(render);

                return NULL;

            };

        }

        render->target = 0;

        render->draw   = draw_hw_picture;

    };

           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);

};

{

        pxDestroyBitmap(render->bitmap[1]);

};

{

    int i;

    render->rcvideo.l = 0;

    render->rcvideo.t = 0;

    render->rcvideo.r = width;

    render->rcvideo.b = 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;

        }

        if(yoffs)

        {

            render->rcbottom.t = render->rcvideo.t+render->rcvideo.b;

            render->rcbottom.b = yoffs;

            render->layout |= HAS_BOTTOM;

        }

    }

    {

        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;

        }

    };

};

{

    uint32_t right, bottom, new_w, new_h;

    uint32_t s, sw, sh;

    uint8_t  state;

    bottom = win->h;

        bottom-= CAPTION_HEIGHT+PANEL_HEIGHT;

 //                   right, bottom);

        return;

        return;

        bottom == render->win_height)

        return;

    new_h = right*render->ctx_height/render->ctx_width;

    {

        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_height = bottom;

    render_set_size(render, new_w, new_h);

    {

        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);

    };

        pxResizeBitmap(render->bitmap[1], new_w, new_h);

};

{

    vst_t *vst = render->vst;

    planar_t *planar = vframe->planar;

    {

        mutex_lock(&render->vst->gpu_lock);

                    CAPTION_HEIGHT+render->rcvideo.t,

                    render->rcvideo.r, render->rcvideo.b,0,0);

        mutex_unlock(&render->vst->gpu_lock);

};

{

    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;

       render->win->win_state == ROLLED)

        return;

    {

        dst_width  = render->ctx_width;

        dst_height = render->ctx_height;

    }

    else

    {

        dst_width  = render->rcvideo.r;

        dst_height = render->rcvideo.b;

    };

    {

        render_hw_planar(render, vframe);

        return;

    };

    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 ;

    };

    if( bitmap_data == NULL)

    {

        printf("Cannot lock bitmap!\n");

        return ;

    }

    data[1] = bitmap_data+1;

    data[2] = bitmap_data+2;

    data[3] = bitmap_data+3;

    linesize[1] = bitmap_pitch;

    linesize[2] = bitmap_pitch;

    linesize[3] = bitmap_pitch;

              picture->linesize, 0, render->ctx_height, data, linesize);

//    printf("sws_scale\n");

    {

            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->target++;

    render->target&= 1;

}

{

    AVPicture *picture;

    uint8_t  *bitmap_data;

    uint32_t  bitmap_pitch;

    uint8_t  *data[4];

    int      linesize[4];

       render->win->win_state == ROLLED)

        return;

              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 ;

    }

    data[1] = bitmap_data+1;

    data[2] = bitmap_data+2;

    data[3] = bitmap_data+3;

    linesize[1] = bitmap_pitch;

    linesize[2] = bitmap_pitch;

    linesize[3] = bitmap_pitch;

              picture->linesize, 0, render->ctx_height, data, linesize);

        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);

}

{

    vst_t *vst = render->vst;

    int y;

       render->win_state == ROLLED )

        return;

    if(render->win_state == FULLSCREEN)

        y = 0;

    else

        y = CAPTION_HEIGHT;

    {

//         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);

    };

        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);

}