Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

#include 

#include "winlib/winlib.h"

#include 

#include "fplay.h"

#include 

extern int res_pause_btn_pressed[];

extern int res_play_btn_pressed[];

extern volatile int sound_level_0;

extern volatile int sound_level_1;

{

    AVPicture      picture;

    double         pts;

    volatile int   ready;

}vframe_t;

volatile int      frames_count = 0;

int dfx    = 0;

int height;

AVFrame  *Frame;

{

    int i;

    {

        frames[i].pts    = 0;

        frames[i].ready  = 0;

    };

    frames_count = 0;

    vfx    = 0;

    dfx    = 0;

};

{

    int        i;

    height = ctx->height;

    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;

    current_clock = -90.0 + get_master_clock();

        Frame->reordered_opaque != AV_NOPTS_VALUE)

        pts = Frame->reordered_opaque;

    else if(pkt.dts != AV_NOPTS_VALUE)

        pts= pkt.dts;

    else

        pts= 0;

*/

    if( 1 /*pts > current_clock*/)

    {

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

//            printf("pts %f\n", frames[dfx].pts);

            dfx&= 3;

            frames_count++;

        };

    };

    av_free_packet(&pkt);

}

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

//    printf("stop player\n");

{

    window_t  *win = (window_t*)ctrl;

    static int spc_down = 0;

    static int ent_down = 0;

    {

        case MSG_SIZE:

            //printf("MSG_SIZE\n");

            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;

                        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_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 = (log2(peak+16384)*10000.0)/15 - 10000;

                    level =  peak;

                    set_audio_volume(level, level);

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

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

                }

                    break;

            }

            break;

            def_window_proc(ctrl,msg,arg1,arg2);

    };

    return 0;

};

extern queue_t  q_audio;

{

    progress_t  *prg = main_render->win->panel.prg;

    level_t     *lvl = main_render->win->panel.lvl;

    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(frames[vfx].ready == 1 )

    {

        int sys_time;

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

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

        {

            delay((int)fdelay/10);

        //    return;

        };

#if 0

        ctime = get_master_clock();

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

//        {

//            yield();

//            ctime = get_master_clock();

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

//        }

//            printf("systime %d pts %f time %f delay %f\n",

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

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

        printf("video cache %d audio cache %d\n", q_video.size/1024, q_audio.size/1024);

#endif

        if(main_render->win->win_state != FULLSCREEN)

        {

            prg->current = frames[vfx].pts*1000;

//        printf("current %f\n", prg->current);

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

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

        }

        frames[vfx].ready = 0;

        vfx++;

        vfx&= 3;

    }

    else delay(1);

    {

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

                    }

                }

            };

        };

        {

           int val = fdelay;

           printf("pts %f time %f delay %d\n",

                   frames[vfx].pts, ctime, val);

           delay(val/10);

        };

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

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

        main_render->win->panel.prg->current = frames[vfx].pts;

//        send_message(&render->win->panel.prg->ctrl, MSG_PAINT, 0, 0);

        frames[vfx].ready = 0;

        vfx++;

        vfx&= 3;

    }

    else yield();

#endif

{

    AVCodecContext *ctx = param;

    window_t  *MainWindow;

                               10,10,width,height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);

//    printf("MainWindow %x\n", MainWindow);

    if( main_render == NULL)

    {

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

        return 0;

    };

    player_state = PLAY;

    fini_winlib();

    return 0;

};

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

{

    render_t *render;

    uint32_t s, sw, sh;

    uint8_t  state;

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

    render->ctx_height = ctx->height;

    render->ctx_format = ctx->pix_fmt;

    render->caps = init_pixlib(flags);

    mutex_unlock(&driver_lock);

    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].width  = draw_w;

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

        {

            free(render);

            return NULL;

        }

        render->draw = draw_sw_picture;

    }

    else

    {

        int width, height, flags;

        int i;

        {

            sna_create_mask();

            height = render->ctx_height;

            flags  = HW_TEX_BLIT;

        }

        else

        {

            width  = draw_w;

            height = draw_h;;

            flags  = HW_BIT_BLIT;

        }

        {

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

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

            render->bitmap[i].flags  = flags;

            {

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

//        printf("create hardware decoder context\n");

};

{

        destroy_bitmap(&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);

        return;

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

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

    {

        render->bitmap[1].width  = new_w;

        render->bitmap[1].height = new_h;

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

    };

    return;

};

{

    int      dst_width, dst_height;

    bitmap_t   *bitmap;

    uint8_t    *data[4];

    int      linesize[4];

    int ret;

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

    {

            fplay_blit_bitmap(bitmap,render->rcvideo.l,render->rcvideo.t,

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

        else

            fplay_blit_bitmap(bitmap, render->rcvideo.l,

                    CAPTION_HEIGHT+render->rcvideo.t,

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

    }

    else

    {

        if(render->win->win_state == FULLSCREEN)

            blit_bitmap(bitmap,render->rcvideo.l,render->rcvideo.t,

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

        else

            blit_bitmap(bitmap, render->rcvideo.l,

                    CAPTION_HEIGHT+render->rcvideo.t,

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

    };

    render->target++;

    render->target&= 1;

}

{

    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,

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

        fplay_blit_bitmap(&render->bitmap[0],render->rcvideo.l,render->rcvideo.t,

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

    else

        fplay_blit_bitmap(&render->bitmap[0], render->rcvideo.l,

                 CAPTION_HEIGHT+render->rcvideo.t,

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

}

{

    int y;

       render->win_state == ROLLED )

        return;

    if(render->win_state == FULLSCREEN)

        y = 0;

    else

        y = CAPTION_HEIGHT;

    {

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

            main_render->draw(main_render, &frames[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);

}

>