WebSVN – Kolibri OS – Diff – /programs/media/Fplay/video.c

     width = ctx->width;
     height = ctx->height;
-    printf("w = %d  h = %d\n\r", ctx->width, ctx->height);
-//    __asm__ __volatile__("int3");
-    main_render = create_render(ctx->width, ctx->height,
-                           ctx->pix_fmt, HW_BIT_BLIT|HW_TEX_BLIT);
-    if( main_render == NULL)
-    {
-        printf("Cannot create render\n\r");
-        return 0;
     };
     Frame = avcodec_alloc_frame();
     if ( Frame == NULL )
     switch(msg)
+    {
         case MSG_SIZE:
             //printf("MSG_SIZE\n");
+            if(main_render)
+            {
-            render_adjust_size(main_render, win);
+                render_adjust_size(main_render, win);
+                render_draw_client(main_render);
+            };
             break;
         case MSG_DRAW_CLIENT:
             render_draw_client(main_render);
 extern char *movie_file;
 int video_thread(void *param)
+{
     AVCodecContext *ctx = param;
-    window_t    *MainWindow;
+    window_t  *MainWindow;
     init_winlib();
     MainWindow = create_window(movie_file,0,
-,10,width,height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
-    MainWindow->panel.prg->max = stream_duration;
+,10,width,height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
+    MainWindow->panel.prg->max = stream_duration;
+//    printf("MainWindow %x\n", MainWindow);
+    show_window(MainWindow, NORMAL);
+//    __asm__ __volatile__("int3");
+    main_render = create_render(MainWindow, ctx, HW_BIT_BLIT|HW_TEX_BLIT);
-//    printf("MainWindow %x\n", MainWindow);
+    if( main_render == NULL)
+    {
-    main_render->win = MainWindow;
+        printf("Cannot create render\n\r");
+        return 0;
     };
     show_window(MainWindow, NORMAL);
     render_draw_client(main_render);
-    render_draw_client(main_render);
+    player_state = PLAY;
     player_state = PLAY;
     run_render(MainWindow, main_render);
-    run_render(MainWindow, main_render);
-    fini_winlib();
+    destroy_render(main_render);
     fini_winlib();
+    player_state = CLOSED;
+    return 0;
+};
     player_state = CLOSED;
     return 0;
-};
+void draw_hw_picture(render_t *render, AVPicture *picture);
+void draw_sw_picture(render_t *render, AVPicture *picture);
+render_t *create_render(window_t *win, AVCodecContext *ctx, uint32_t flags)
+{
-void draw_hw_picture(render_t *render, AVPicture *picture);
+    render_t *render;
 void draw_sw_picture(render_t *render, AVPicture *picture);
     uint32_t right, bottom, draw_w, draw_h;
-render_t *create_render(uint32_t width, uint32_t height,
+    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->win = win;
+    render->ctx_width  = ctx->width;
+    render->ctx_height = ctx->height;
+    render->ctx_format = ctx->pix_fmt;
+    mutex_lock(&driver_lock);
+    render->caps = init_pixlib(flags);
+    mutex_unlock(&driver_lock);
+    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)
                         uint32_t ctx_format, uint32_t flags)
         draw_w = right;
+        draw_h = right*render->ctx_height/render->ctx_width;
+    };
-    render_t *render;
+    if(draw_h > bottom)
+    {
+        draw_h = bottom;
+        draw_w = bottom*render->ctx_width/render->ctx_height;
+    };
-//    __asm__ __volatile__("int3");
+    render->win_width  = win->w;
     render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
     render = (render_t*)malloc(sizeof(render_t));
+    render_set_size(render, draw_w, draw_h);
+    if(render->caps==0)
+    {
+        render->bitmap[0].width  = draw_w;
+        render->bitmap[0].height = draw_h;
+        if( create_bitmap(&render->bitmap[0]) != 0 )
+        {
+            free(render);
+            return NULL;
+        }
+        render->draw = draw_sw_picture;
+    }
+    else
+    {
+        int width, height, flags;
+        int i;
+        if(render->caps & HW_TEX_BLIT)
+        {
+            sna_create_mask();
+            width  = render->ctx_width;
+            height = render->ctx_height;
+            flags  = HW_TEX_BLIT;
+        }
+        else
+        {
+            width  = draw_w;
+            height = draw_h;;
+            flags  = HW_BIT_BLIT;
     memset(render, 0, sizeof(render_t));
-    render->ctx_width  = width;
+        for( i=0; i < 2; i++)
+        {
+            render->bitmap[i].width  = width;
+            render->bitmap[i].height = height;
-    render->ctx_height = height;
+            render->bitmap[i].flags  = flags;
-    render->ctx_format = ctx_format;
+            if( create_bitmap(&render->bitmap[i]) != 0 )
+            {
+                player_state = CLOSED;
+                free(render);
+                return NULL;
+            };
+        }
+        render->state = INIT;
+        render->target = 0;
+        render->draw   = draw_hw_picture;
+    };
-    mutex_lock(&driver_lock);
+    printf("FPlay %s render engine: context %dx%d picture %dx%d\n",
-    render->caps = init_pixlib(flags);
+           render->caps==0 ? "software":"hardware",
-    mutex_unlock(&driver_lock);
+           render->ctx_width, render->ctx_height,
            draw_w, draw_h);
     if(render->caps==0)
             render->rcright.r = xoffs;
             render->layout |= HAS_RIGHT;
+        }
     };
 };
-    if(render->state == EMPTY)
-    {
-        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;
-                render->bitmap[i].flags  = HW_TEX_BLIT;
-                if( create_bitmap(&render->bitmap[i]) != 0 )
-                {
-                    player_state = CLOSED;
-/*
- *  Epic fail. Need  exit_thread() here
- *
-*/
-                    return 0;
-                };
-            }
-        }
-        else
-        {
-            render->bitmap[0].width  = width;
-            render->bitmap[0].height = height;
-            render->bitmap[0].flags  = HW_BIT_BLIT;
-            if( create_bitmap(&render->bitmap[0]) != 0 )
-                return 0;
-        };
-        render->state = INIT;
-        return 0;
-    };
-    if(render->caps & HW_TEX_BLIT)          /*  hw scaler  */
-        return 0;
-    render->bitmap[0].width  = width;
-    render->bitmap[0].height = height;
-    resize_bitmap(&render->bitmap[0]);
-    return 0;
-};
 void render_adjust_size(render_t *render, window_t *win)
+{
     uint32_t right, bottom, new_w, new_h;
     render->win_width  = win->w;
     render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
     render_set_size(render, new_w, new_h);
+    if(render->caps & HW_TEX_BLIT)          /*  hw scaler  */
+        return;
+    render->bitmap[0].width  = new_w;
+    render->bitmap[0].height = new_h;
+    resize_bitmap(&render->bitmap[0]);
+    if(render->caps & HW_BIT_BLIT)          /* hw blitter */
+    {
+        render->bitmap[1].width  = new_w;
+        render->bitmap[1].height = new_h;
+        resize_bitmap(&render->bitmap[1]);
+    };
+    return;
 };
 void draw_hw_picture(render_t *render, AVPicture *picture)
+{
     int      dst_width, dst_height;
     bitmap_t   *bitmap;
     uint8_t    *data[4];
     int      linesize[4];
     int ret;
-    if(render->win_state == MINIMIZED ||
+    if(render->win->win_state == MINIMIZED ||
-       render->win_state == ROLLED)
+       render->win->win_state == ROLLED)
         return;
     render->last_bitmap = bitmap;
 //    printf("blit_bitmap\n");
-//    render->target++;
+    render->target++;
-//    render->target&= 3;
+    render->target&= 1;
+}
 void draw_sw_picture(render_t *render, AVPicture *picture)
 {
     uint8_t     *data[4];
     int      linesize[4];
-    if(render->win_state == MINIMIZED ||
+    if(render->win->win_state == MINIMIZED ||
-       render->win_state == ROLLED)
+       render->win->win_state == ROLLED)
         printf("Cannot initialize the conversion context!\n");
         return ;
+    }
+    lock_bitmap(&render->bitmap[0]);
     data[0] = render->bitmap[0].data;
     data[1] = render->bitmap[0].data+1;
     data[2] = render->bitmap[0].data+2;
     data[3] = render->bitmap[0].data+3;

Subversion Repositories Kolibri OS

(root)/programs/media/Fplay/video.c @ 3334 – Rev 3248 → 3292