Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include "sound.h"

#include "fplay.h"

{

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

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

};

static int frame_count;

{

    AVPacket   pkt;

    double     pts;

    double av_time;

        return 1;

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

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

        frames[dfx].ready = 1;

        dfx&= 3;

    };

    av_free_packet(&pkt);

}

rect_t     win_rect;

{

    int ev;

    {

       case 1:

            render_adjust_size(render);

            BeginDraw();

            DrawWindow(0,0,0,0, NULL, 0x000000,0x73);

            EndDraw();

            break;

            if(get_os_button()==1)

                status = 0;

            break;

    };

    return 1;

}

{

    rect_t rc;

    AVCodecContext *ctx = param;

    DrawWindow(10, 10, width+9, height+26, movie_file, 0x000000,0x73);

    EndDraw();

    {

        double ctime;

        double fdelay;

        {

            ctime = get_master_clock();

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

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

            {

                int  next_vfx;

                fdelay = 0;

                next_vfx = (vfx+1) & 3;

                if( frames[next_vfx].ready == 1 )

                {

                    if(frames[next_vfx].pts <= ctime)

                    {

                        frames[vfx].ready = 0;                  // skip this frame

                        vfx++;

                        vfx&= 3;

                     }

                    else

                    {

                        if( (frames[next_vfx].pts - ctime) <

                            ( ctime - frames[vfx].pts) )

                        {

                            frames[vfx].ready = 0;                  // skip this frame

                            vfx++;

                            vfx&= 3;

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

                        }

                    }

                };

            };

            {

                delay( (uint32_t)(fdelay/10.0));

            };

//                    frames[vfx].frame->linesize[0]);

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

            frames[vfx].ready = 0;

            vfx++;

            vfx&= 3;

        }

        else

        {

            yield();

        };

    };

    return 0;

};

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

                        uint32_t ctx_format, uint32_t flags)

{

    render_t *ren;

    memset(ren, 0, sizeof(*ren));

    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->win_height = height;

    render->win_state = NORMAL;

    {

        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;

                {

                    status = 0;

/*

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

};

{

    char proc_info[1024];

    uint32_t s, sw, sh;

    uint8_t  state;

    bottom = *(uint32_t*)(proc_info+66)+1;

    state  = *(uint8_t*)(proc_info+70);

    {   render->win_state = MINIMIZED;

        return;

    }

    if(state & 4)

    {

        render->win_state = ROLLED;

        return;

    };

        bottom == render->win_height)

        return;

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

//    printf("new_w %d new_h %d\n", new_w, new_h);

    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;

    };

    __asm__ __volatile__(

    "int $0x40"

     ::"a"(67), "b"(-1), "c"(-1),

     "d"(new_w+9),"S"(new_h+26)

     :"memory" );

    render_set_size(render, new_w, new_h);

{

    int      dst_width, dst_height;

    uint8_t     *data[4];

    int      linesize[4];

        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 ;

    };

//    printf("sws_getCachedContext\n");

    data[0] = render->bitmap[render->target].data;

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

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

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

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

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

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

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

//    printf("sws_scale\n");

                 render->win_width, render->win_height);

//    printf("blit_bitmap\n");

    render->target++;

    render->target&= 3;

}

{

    uint8_t     *data[4];

    int      linesize[4];

        return;

              render->ctx_width, render->ctx_height,

              render->ctx_format,

              render->win_width, render->win_height,

              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->win_width, render->win_height);

}

>