Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 3292 → Rev 3291

/programs/media/Fplay/OPENDIAL.ASM
File deleted
/programs/media/Fplay/fplay.h
106,11 → 106,12
extern astream_t astream;
extern AVRational video_time_base;
 
render_t *create_render(window_t *win, AVCodecContext *ctx, uint32_t flags);
void destroy_render(render_t *render);
render_t *create_render(uint32_t width, uint32_t height,
uint32_t ctx_format, uint32_t flags);
 
int init_render(render_t *render, int width, int height);
void render_adjust_size(render_t *render, window_t *win);
void render_set_size(render_t *render, int width, int height);
int render_set_size(render_t *render, int width, int height);
void render_draw_client(render_t *render);
 
 
/programs/media/Fplay/pixlib2.c
23,18 → 23,8
#define __ALIGN_MASK(x,mask) (((x)+(mask))&~(mask))
#define ALIGN(x,a) __ALIGN_MASK(x,(typeof(x))(a)-1)
 
int sna_init(uint32_t service);
void sna_fini();
 
int sna_create_bitmap(bitmap_t *bitmap);
void sna_destroy_bitmap(bitmap_t *bitmap);
void sna_lock_bitmap(bitmap_t *bitmap);
int sna_blit_copy(bitmap_t *src_bitmap, int dst_x, int dst_y,
int w, int h, int src_x, int src_y);
int sna_blit_tex(bitmap_t *src_bitmap, int dst_x, int dst_y,
int w, int h, int src_x, int src_y);
 
 
static uint32_t service;
static uint32_t blit_caps;
static uint32_t screen_width;
51,6 → 41,7
}ioctl_t;
 
 
 
typedef struct
{
uint32_t idx;
130,7 → 121,6
(DISPLAY_VERSION < (api_version >> 16)))
goto fail;
 
#if 0
/*
* Let's see what this service can do
*/
155,16 → 145,8
(blit_caps & HW_BIT_BLIT) != 0 ?"HW_BIT_BLIT ":"",
(blit_caps & HW_TEX_BLIT) != 0 ?"HW_TEX_BLIT ":"",
(blit_caps & HW_VID_BLIT) != 0 ?"HW_VID_BLIT ":"");
#endif
 
blit_caps = caps & sna_init(service);
 
if( blit_caps )
printf("service caps %s%s%s\n",
(blit_caps & HW_BIT_BLIT) != 0 ?"HW_BIT_BLIT ":"",
(blit_caps & HW_TEX_BLIT) != 0 ?"HW_TEX_BLIT ":"",
(blit_caps & HW_VID_BLIT) != 0 ?"HW_VID_BLIT ":"");
blit_caps&= caps;
return blit_caps;
 
fail:
172,28 → 154,62
return 0;
};
 
void done_pixlib()
 
int create_bitmap(bitmap_t *bitmap)
{
// __asm__ __volatile__("int3");
sna_fini();
if( bitmap->flags && blit_caps & HW_BIT_BLIT )
{
struct __attribute__((packed)) /* SRV_CREATE_SURFACE */
{
uint32_t handle; // ignored
void *data; // ignored
};
uint32_t width;
uint32_t height;
uint32_t pitch; // ignored
 
uint32_t max_width;
uint32_t max_height;
uint32_t format; // reserved mbz
}io_10;
 
int create_bitmap(bitmap_t *bitmap)
ioctl_t io;
int err;
 
// printf("create bitmap %d x %d\n",
// bitmap->width, bitmap->height);
 
io_10.width = bitmap->width;
io_10.height = bitmap->height;
io_10.max_width = screen_width;
io_10.max_height = screen_height;
io_10.format = 0;
 
io.handle = service;
io.io_code = SRV_CREATE_SURFACE;
io.input = &io_10;
io.inp_size = BUFFER_SIZE(8);
io.output = NULL;
io.out_size = 0;
 
err = call_service(&io);
if(err==0)
{
// __asm__ __volatile__("int3");
bitmap->handle = io_10.handle;
bitmap->pitch = io_10.pitch;
bitmap->data = io_10.data;
// printf("Create hardware surface %x pitch %d, buffer %x\n",
// bitmap->handle, bitmap->pitch, bitmap->data);
return 0;
};
};
 
uint32_t size;
uint32_t pitch;
uint8_t *buffer;
 
if( bitmap->flags & (HW_BIT_BLIT | HW_TEX_BLIT ))
return sna_create_bitmap(bitmap);
 
// if( bitmap->flags && blit_caps & HW_BIT_BLIT )
// return sna_create_bitmap(bitmap);
 
pitch = ALIGN(bitmap->width*4, 16);
size = pitch * bitmap->height;
 
210,35 → 226,95
printf("Cannot alloc frame buffer\n\r");
 
return -1;
};
 
int destroy_bitmap(bitmap_t *bitmap)
{
if( bitmap->flags & (HW_BIT_BLIT | HW_TEX_BLIT ))
sna_destroy_bitmap(bitmap);
return 0;
};
 
int lock_bitmap(bitmap_t *bitmap)
{
// __asm__ __volatile__("int3");
int err = 0;
 
if( bitmap->flags & (HW_BIT_BLIT | HW_TEX_BLIT ))
sna_lock_bitmap(bitmap);
if( bitmap->flags && blit_caps & HW_BIT_BLIT )
{
struct __attribute__((packed)) /* SRV_LOCK_SURFACE */
{
uint32_t handle;
void *data;
uint32_t pitch;
 
return 0;
}io_12;
 
ioctl_t io;
 
io_12.handle = bitmap->handle;
io_12.pitch = 0;
io_12.data = 0;
 
io.handle = service;
io.io_code = SRV_LOCK_SURFACE;
io.input = &io_12;
io.inp_size = BUFFER_SIZE(3);
io.output = NULL;
io.out_size = 0;
 
err = call_service(&io);
if(err==0)
{
bitmap->pitch = io_12.pitch;
bitmap->data = io_12.data;
// printf("Lock hardware surface %x pitch %d, buffer %x\n",
// bitmap->handle, bitmap->pitch, bitmap->data);
};
};
 
return err;
};
 
int blit_bitmap(bitmap_t *bitmap, int dst_x, int dst_y,
int w, int h)
{
int err;
 
if( bitmap->flags & (HW_BIT_BLIT | HW_TEX_BLIT ) )
return sna_blit_tex(bitmap, dst_x, dst_y, w, h, 0, 0);
if( bitmap->flags && blit_caps & HW_BIT_BLIT )
{
 
/*
* Now you will experience the full power of the dark side...
*/
 
struct __attribute__((packed))
{
uint32_t handle;
int dst_x;
int dst_y;
int src_x;
int src_y;
uint32_t w;
uint32_t h;
}io_15;
 
ioctl_t io;
 
io_15.handle = bitmap->handle;
io_15.dst_x = dst_x;
io_15.dst_y = dst_y;
io_15.src_x = 0;
io_15.src_y = 0;
io_15.w = w;
io_15.h = h;
 
io.handle = service;
io.io_code = SRV_BLIT_BITMAP;
io.input = &io_15;
io.inp_size = BUFFER_SIZE(7);
io.output = NULL;
io.out_size = 0;
 
// printf("do blit %x pitch %d\n",bitmap->handle,
// bitmap->pitch);
err = call_service(&io);
return err;
};
 
struct blit_call bc;
 
bc.dstx = dst_x;
/programs/media/Fplay/video.c
68,7 → 68,18
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 )
{
218,11 → 229,7
{
case MSG_SIZE:
//printf("MSG_SIZE\n");
if(main_render)
{
render_adjust_size(main_render, win);
render_draw_client(main_render);
};
break;
 
case MSG_DRAW_CLIENT:
487,7 → 494,6
 
int video_thread(void *param)
{
AVCodecContext *ctx = param;
window_t *MainWindow;
init_winlib();
498,23 → 504,15
MainWindow->panel.prg->max = stream_duration;
// printf("MainWindow %x\n", MainWindow);
 
main_render->win = MainWindow;
 
show_window(MainWindow, NORMAL);
 
// __asm__ __volatile__("int3");
 
main_render = create_render(MainWindow, ctx, HW_BIT_BLIT|HW_TEX_BLIT);
if( main_render == NULL)
{
printf("Cannot create render\n\r");
return 0;
};
 
render_draw_client(main_render);
player_state = PLAY;
 
run_render(MainWindow, main_render);
 
destroy_render(main_render);
fini_winlib();
 
player_state = CLOSED;
525,130 → 523,41
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)
render_t *create_render(uint32_t width, uint32_t height,
uint32_t ctx_format, uint32_t flags)
{
render_t *render;
 
uint32_t right, bottom, draw_w, draw_h;
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 = width;
render->ctx_height = height;
render->ctx_format = ctx_format;
 
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)
{
draw_w = right;
draw_h = right*render->ctx_height/render->ctx_width;
};
if(draw_h > bottom)
{
draw_h = bottom;
draw_w = bottom*render->ctx_width/render->ctx_height;
};
 
render->win_width = win->w;
render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
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;
}
printf("FPlay render engine: Hardware acceleration disabled\n");
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;
}
 
for( i=0; i < 2; i++)
{
render->bitmap[i].width = width;
render->bitmap[i].height = height;
render->bitmap[i].flags = flags;
 
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;
};
printf("FPlay %s render engine: context %dx%d picture %dx%d\n",
render->caps==0 ? "software":"hardware",
render->ctx_width, render->ctx_height,
draw_w, draw_h);
render->state = EMPTY;
return render;
};
 
void destroy_render(render_t *render)
int render_set_size(render_t *render, int width, int height)
{
 
destroy_bitmap(&render->bitmap[0]);
if(render->caps & (HW_BIT_BLIT|HW_TEX_BLIT)) /* hw blitter */
destroy_bitmap(&render->bitmap[1]);
done_pixlib();
};
 
void render_set_size(render_t *render, int width, int height)
{
int i;
 
render->layout = 0;
698,8 → 607,51
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;
741,22 → 693,7
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)
{
766,8 → 703,8
int linesize[4];
int ret;
 
if(render->win->win_state == MINIMIZED ||
render->win->win_state == ROLLED)
if(render->win_state == MINIMIZED ||
render->win_state == ROLLED)
return;
 
if(render->caps & HW_TEX_BLIT)
823,8 → 760,8
// printf("blit_bitmap\n");
 
 
render->target++;
render->target&= 1;
// render->target++;
// render->target&= 3;
}
 
void draw_sw_picture(render_t *render, AVPicture *picture)
832,8 → 769,8
uint8_t *data[4];
int linesize[4];
 
if(render->win->win_state == MINIMIZED ||
render->win->win_state == ROLLED)
if(render->win_state == MINIMIZED ||
render->win_state == ROLLED)
return;
 
cvt_ctx = sws_getCachedContext(cvt_ctx,
847,8 → 784,6
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;
/programs/media/Fplay/winlib/caption.c
160,6 → 160,7
rc.r = cpt->ctrl.w - 25 - 16 - 5 - 8;
rc.b = 18;
printf(cpt->text);
draw_text_ext(cpt->ctx.pixmap, win_font, cpt->text, &rc, 0xFFFFFFFF);
 
ctrl_t *child;
218,6 → 219,7
switch((short)arg1)
{
case ID_CLOSE:
win = (window_t*)ctrl->parent;
win->win_command = WIN_CLOSED;
break;
 
225,8 → 227,6
__asm__ __volatile__(
"int $0x40"
::"a"(18),"b"(10));
win->win_state = MINIMIZED;
send_message((ctrl_t*)win, MSG_SIZE, 0, 0);
break;
default:
break;
/programs/media/Fplay/winlib/window.c
52,48 → 52,31
window_t *create_window(char *caption, int style, int x, int y,
int w, int h, handler_t handler)
{
char proc_info[1024];
int stride;
ctx_t *ctx = &Window.client_ctx;
 
// __asm__ __volatile__("int3");
 
// ctx_t *ctx = &Window.client_ctx;
 
if(handler==0) return 0;
 
BeginDraw();
DrawWindow(x, y, w-1, h-1,
NULL,0,0x41);
EndDraw();
 
get_proc_info(proc_info);
 
x = *(uint32_t*)(proc_info+34);
y = *(uint32_t*)(proc_info+38);
w = *(uint32_t*)(proc_info+42)+1;
h = *(uint32_t*)(proc_info+46)+1;
 
Window.handler = handler;
// Window.ctx = ctx;
Window.ctx = ctx;
 
list_initialize(&Window.link);
list_initialize(&Window.child);
 
 
// Window.bitmap.width = 1920;
// Window.bitmap.height = 1080;
// Window.bitmap.flags = 0;
Window.bitmap.width = 1920;
Window.bitmap.height = 1080;
Window.bitmap.flags = 0;
 
// if( create_bitmap(&Window.bitmap) )
// {
// printf("not enough memory for window bitmap\n");
// return 0;
// }
if( create_bitmap(&Window.bitmap) )
{
printf("not enough memory for window bitmap\n");
return 0;
}
 
// ctx->pixmap = &Window.bitmap;
// ctx->offset_x = 0;
// ctx->offset_y = 0;
ctx->pixmap = &Window.bitmap;
ctx->offset_x = 0;
ctx->offset_y = 0;
 
Window.rc.l = x;
Window.rc.t = y;
270,7 → 253,6
winh == win->h)
return;
 
#if 0
int old_size;
int new_size;
int pitch;
289,7 → 271,6
 
win->bitmap.width = win->w;
win->bitmap.pitch = pitch;
#endif
 
win->rc.r = winx + winw;
win->rc.b = winy + winh;
572,10 → 553,10
list_initialize(&timers);
};
 
//ctx_t *get_window_ctx()
//{
// return &Window.client_ctx;
//};
ctx_t *get_window_ctx()
{
return &Window.client_ctx;
};
 
void update_rect(ctrl_t *ctrl)
{