Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include "system.h"

#include "../winlib/winlib.h"

#include "sound.h"

#include "fplay.h"

extern int res_pause_btn_pressed[];

extern int res_play_btn_pressed[];

{

    AVPicture      picture;

    double         pts;

    volatile int   ready;

}vframe_t;

int dfx    = 0;

int height;

AVFrame  *Frame;

{

    int        i;

    height = ctx->height;

                           ctx->pix_fmt, HW_BIT_BLIT|HW_TEX_BLIT);

//    render = create_render(ctx->width, ctx->height,

//                           ctx->pix_fmt, 0);

//

    if( main_render == NULL)

    {

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

        return 0;

    };

    if ( Frame == NULL )

    {

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

        return 0;

    };

    {

        int ret;

//                   ctx->width, ctx->height, ctx->pix_fmt );

                               ctx->width, ctx->height);

        if ( ret != 0 )

        {

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

            return 0;

        };

        frames[i].ready  = 0;

    };

    return 1;

};

{

    AVPacket   pkt;

    double     pts;

    int frameFinished;

    double current_clock;

        return 1;

        return 0;

        Frame->reordered_opaque != AV_NOPTS_VALUE)

    pts = Frame->reordered_opaque;

        else if(pkt.dts != AV_NOPTS_VALUE)

        pts= pkt.dts;

    else

        pts= 0;

    {

        frameFinished = 0;

            printf("video decoder error\n");

        {

            AVPicture *dst_pic;

                Frame->reordered_opaque != AV_NOPTS_VALUE)

            pts = Frame->reordered_opaque;

            else if(pkt.dts != AV_NOPTS_VALUE)

                pts= pkt.dts;

            else

                pts= 0;

//                                Frame, "best_effort_timestamp");

//            pts = 0;

                      (const uint8_t**)Frame->data,

                      Frame->linesize, ctx->pix_fmt, ctx->width, ctx->height);

            frames[dfx].ready = 1;

            dfx&= 3;

        };

    };

    av_free_packet(&pkt);

}

//rect_t     win_rect;

{

    window_t  *win;

    {

        case MSG_SIZE:

            //printf("MSG_SIZE\n");

            render_adjust_size(main_render, win);

            break;

            render_draw_client(main_render);

            break;

            if(player_state == PAUSE)

            {

                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, MSG_PAINT, 0, 0);

                player_state = PLAY_RESTART;

            else if(player_state == PLAY)

            {

                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, MSG_PAINT, 0, 0);

                player_state = PAUSE;

            }

            break;

            switch((short)arg1)

            {

                case ID_PLAY:

                    if(player_state == PAUSE)

                    {

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

                    }

                    else if(player_state == PLAY)

                    {

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

                    }

                    break;

                default:

                    break;

            }

            break;

            def_window_proc(ctrl,msg,arg1,arg2);

    };

    return 0;

};

{

    double ctime;            /*    milliseconds    */

    double fdelay;           /*    milliseconds    */

    {

        render->win->win_command = WIN_CLOSED;

        return;

    }

    else if(player_state != PLAY)

    {

        yield();

        return;

    };

    {

        ctime = get_master_clock();

        fdelay = (frames[vfx].pts - ctime);

 //               frames[vfx].pts, ctime, fdelay);

        {

            delay(2);

//            yield();

            return;

        };

        frames[vfx].ready = 0;

        vfx++;

        vfx&= 3;

    }

    else yield();

{

    window_t    *MainWindow;

                               10,10,width,height+29+75,MainWindowProc);

    run_render(MainWindow, main_render);

    player_state = CLOSED;

    return 0;

};

void draw_sw_picture(render_t *render, AVPicture *picture);

                        uint32_t ctx_format, uint32_t flags)

{

    render_t *render;

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

    render->ctx_height = height;

    render->ctx_format = ctx_format;

    render->caps = InitPixlib(flags);

    mutex_unlock(&driver_lock);

    {

        printf("FPlay render engine: Hardware acceleration disabled\n");

        render->draw = draw_sw_picture;

    }

    else

    {

        render->target = 0;

        render->draw   = draw_hw_picture;

    };

    return render;

};

{

    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;

        }

    };

    {

        if(render->caps & HW_TEX_BLIT)

        {

            for( i=0; i < 4; i++)

            {

                render->bitmap[i].width  = render->ctx_width;

                render->bitmap[i].height = render->ctx_height;

                {

                    player_state = CLOSED;

/*

 *  Epic fail. Need  exit_thread() here

 *

*/

                    return 0;

                };

            }

        }

        else

        {

            render->bitmap[0].width  = width;

            render->bitmap[0].height = height;

                return 0;

        };

        render->state = INIT;

        return 0;

    };

        return 0;

    render->bitmap[0].height = height;

    resize_bitmap(&render->bitmap[0]);

};

{

    uint32_t right, bottom, new_w, new_h;

    uint32_t s, sw, sh;

    uint8_t  state;

    bottom = win->h-CAPTION_HEIGHT-75;

    render->win_state  = win->win_state;

        return;

        return;

        bottom == render->win_height)

        return;

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

    sw = right * new_h;

    sh = bottom * new_w;

        new_h = bottom;

    else

        new_w = right;

    {

        new_w = 64;

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

    };

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

    render_set_size(render, new_w, new_h);

};

{

    int      dst_width, dst_height;

    bitmap_t   *bitmap;

    uint8_t    *data[4];

    int      linesize[4];

    int ret;

       render->win_state == ROLLED)

        return;

    {

        dst_width  = render->ctx_width;

        dst_height = render->ctx_height;

    }

    else

    {

        dst_width  = render->win_width;

        dst_height = render->win_height;

    };

              render->ctx_width, render->ctx_height, render->ctx_format,

              dst_width, dst_height, PIX_FMT_BGRA,

              SWS_FAST_BILINEAR, NULL, NULL, NULL);

    if(cvt_ctx == NULL)

    {

        printf("Cannot initialize the conversion context!\n");

        return ;

    };

    if( ret != 0)

    {

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

        return ;

    }

    data[0] = bitmap->data;

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

                 CAPTION_HEIGHT+render->rcvideo.t,

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

    render->last_bitmap = bitmap;

//    printf("blit_bitmap\n");

    render->target&= 3;

}

{

    uint8_t     *data[4];

    int      linesize[4];

       render->win_state == ROLLED)

        return;

              render->ctx_width, render->ctx_height,

              render->ctx_format,

              render->rcvideo.r, render->rcvideo.b,

              PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);

    if(cvt_ctx == NULL)

    {

        printf("Cannot initialize the conversion context!\n");

        return ;

    }

    data[1] = render->bitmap[0].data+1;

    data[2] = render->bitmap[0].data+2;

    data[3] = render->bitmap[0].data+3;

    linesize[1] = render->bitmap[0].pitch;

    linesize[2] = render->bitmap[0].pitch;

    linesize[3] = render->bitmap[0].pitch;

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

                render->rcvideo.t+CAPTION_HEIGHT,

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

    render->last_bitmap = &render->bitmap[0];

}

{

    if(render->win_state == MINIMIZED ||

       render->win_state == ROLLED)

        return;

    {

        main_render->draw(main_render, &frames[vfx].picture);

    };

        draw_bar(0, CAPTION_HEIGHT, render->win_width,

                 render->rctop.b, 0);

    if(render->layout & HAS_LEFT)

        draw_bar(0, render->rcvideo.t+CAPTION_HEIGHT, render->rcleft.r,

                 render->rcvideo.b, 0);

    if(render->layout & HAS_RIGHT)

        draw_bar(render->rcright.l, render->rcvideo.t+CAPTION_HEIGHT,

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

    if(render->layout & HAS_BOTTOM)

        draw_bar(0, render->rcbottom.t+CAPTION_HEIGHT,

                 render->win_width, render->rcbottom.b, 0);

}