Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 2414 → Rev 2415

/programs/media/Fplay/video.c
3,6 → 3,9
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>
#include "system.h"
#include <winlib.h>
#include "sound.h"
#include "fplay.h"
 
21,7 → 24,7
int vfx = 0;
int dfx = 0;
 
render_t *render;
render_t *main_render;
 
int width;
int height;
45,9 → 48,12
 
// __asm__ __volatile__("int3");
 
render = create_render(ctx->width, ctx->height,
main_render = create_render(ctx->width, ctx->height,
ctx->pix_fmt, HW_BIT_BLIT|HW_TEX_BLIT);
if( render == NULL)
// render = create_render(ctx->width, ctx->height,
// ctx->pix_fmt, 0);
//
if( main_render == NULL)
{
printf("Cannot create render\n\r");
return 0;
85,14 → 91,11
return 1;
};
 
int frameFinished=0;
static int frame_count;
 
int decode_video(AVCodecContext *ctx, queue_t *qv)
{
AVPacket pkt;
double pts;
double av_time;
int frameFinished;
 
if(frames[dfx].ready != 0 )
return 1;
130,7 → 133,8
 
dst_pic = &frames[dfx].picture;
 
av_image_copy(dst_pic->data, dst_pic->linesize, Frame->data,
av_image_copy(dst_pic->data, dst_pic->linesize,
(const uint8_t**)Frame->data,
Frame->linesize, ctx->pix_fmt, ctx->width, ctx->height);
 
frames[dfx].pts = pts*1000.0;
147,49 → 151,48
extern volatile uint32_t status;
rect_t win_rect;
 
int check_events()
 
int MainWindowProc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2)
{
int ev;
window_t *win;
 
ev = check_os_event();
win = (window_t*)ctrl;
 
switch(ev)
switch(msg)
{
case 1:
render_adjust_size(render);
BeginDraw();
DrawWindow(0,0,0,0, NULL, 0x000000,0x73);
EndDraw();
case MSG_SIZE:
//printf("MSG_SIZE\n");
render_adjust_size(main_render, win);
break;
 
case 3:
if(get_os_button()==1)
status = 0;
case MSG_DRAW_CLIENT:
render_draw_client(main_render);
break;
};
return 1;
}
 
 
extern char *movie_file;
 
int video_thread(void *param)
case MSG_COMMAND:
switch((short)arg1)
{
rect_t rc;
AVCodecContext *ctx = param;
case ID_CLOSE:
exit(0);
};
break;
 
BeginDraw();
DrawWindow(10, 10, width+9, height+26, movie_file, 0x000000,0x73);
EndDraw();
default:
def_window_proc(ctrl,msg,arg1,arg2);
};
return 0;
};
 
render_adjust_size(render);
 
while( status != 0)
void render_time(render_t *render)
{
double ctime;
double fdelay;
 
check_events();
if(status == 0)
{
render->win->win_command = WIN_CLOSED;
return;
};
 
if(frames[vfx].ready == 1 )
{
231,18 → 234,33
delay( (uint32_t)(fdelay/10.0));
};
 
// blit_bitmap(&frames[vfx].bitmap, 5, 22, width, height);
// frames[vfx].frame->linesize[0]);
render->draw(render, &frames[vfx].picture);
main_render->draw(main_render, &frames[vfx].picture);
frames[vfx].ready = 0;
vfx++;
vfx&= 3;
};
}
else
 
extern char *movie_file;
 
int video_thread(void *param)
{
yield();
};
};
window_t *MainWindow;
 
init_winlib();
 
MainWindow = create_window(movie_file,0,
10,10,width+14,height+29,MainWindowProc);
 
// printf("MainWindow %x\n", MainWindow);
 
main_render->win = MainWindow;
 
show_window(MainWindow, NORMAL);
run_render(MainWindow, main_render);
 
// printf("exit thread\n");
status = 0;
return 0;
};
 
253,11 → 271,13
render_t *create_render(uint32_t width, uint32_t height,
uint32_t ctx_format, uint32_t flags)
{
render_t *ren;
render_t *render;
 
render = (render_t*)malloc(sizeof(*ren));
memset(ren, 0, sizeof(*ren));
// __asm__ __volatile__("int3");
 
render = (render_t*)malloc(sizeof(render_t));
memset(render, 0, sizeof(render_t));
 
render->ctx_width = width;
render->ctx_height = height;
render->ctx_format = ctx_format;
285,12 → 305,52
{
int i;
 
render->win_width = width;
render->win_height = height;
render->win_state = NORMAL;
render->layout = 0;
render->rcvideo.l = 0;
render->rcvideo.t = 0;
render->rcvideo.r = width;
render->rcvideo.b = height;
 
// printf("%s %dx%d\n",__FUNCTION__, width, height);
if( render->win_height > 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;
}
 
yoffs = render->win_height-(render->rcvideo.t+render->rcvideo.b);
if(yoffs)
{
render->rcbottom.t = render->rcvideo.t+render->rcvideo.b;
render->rcbottom.b = yoffs;
render->layout |= HAS_BOTTOM;
}
}
 
if( render->win_width > width )
{
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->state == EMPTY)
{
if(render->caps & HW_TEX_BLIT)
333,32 → 393,23
return 0;
};
 
void render_adjust_size(render_t *render)
void render_adjust_size(render_t *render, window_t *win)
{
char proc_info[1024];
 
uint32_t right, bottom, new_w, new_h;
uint32_t s, sw, sh;
uint8_t state;
 
get_proc_info(proc_info);
 
right = *(uint32_t*)(proc_info+62)+1;
bottom = *(uint32_t*)(proc_info+66)+1;
state = *(uint8_t*)(proc_info+70);
right = win->w;
bottom = win->h-29;
render->win_state = win->win_state;
 
if(state & 2)
{ render->win_state = MINIMIZED;
if(render->win_state == MINIMIZED)
return;
}
if(state & 4)
{
render->win_state = ROLLED;
 
if(render->win_state == ROLLED)
return;
};
 
render->win_state = NORMAL;
 
if( right == render->win_width &&
bottom == render->win_height)
return;
366,7 → 417,6
new_w = bottom*render->ctx_width/render->ctx_height;
new_h = right*render->ctx_height/render->ctx_width;
 
// printf("right %d bottom %d\n", right, bottom);
// printf("new_w %d new_h %d\n", new_w, new_h);
 
s = right * bottom;
383,22 → 433,21
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->win_width = win->w;
render->win_height = win->h-29;
render_set_size(render, new_w, new_h);
 
};
 
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 != NORMAL)
if(render->win_state == ROLLED)
return;
 
if(render->caps & HW_TEX_BLIT)
421,26 → 470,37
printf("Cannot initialize the conversion context!\n");
return ;
};
 
bitmap = &render->bitmap[render->target];
 
ret = lock_bitmap(bitmap);
if( ret != 0)
{
printf("Cannot lock the bitmap!\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;
data[0] = bitmap->data;
data[1] = bitmap->data+1;
data[2] = bitmap->data+2;
data[3] = bitmap->data+3;
 
linesize[0] = render->bitmap[render->target].pitch;
linesize[1] = render->bitmap[render->target].pitch;
linesize[2] = render->bitmap[render->target].pitch;
linesize[3] = render->bitmap[render->target].pitch;
linesize[0] = bitmap->pitch;
linesize[1] = bitmap->pitch;
linesize[2] = bitmap->pitch;
linesize[3] = bitmap->pitch;
 
sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
picture->linesize, 0, render->ctx_height, data, linesize);
// printf("sws_scale\n");
 
blit_bitmap(&render->bitmap[render->target], 5, 22,
render->win_width, render->win_height);
blit_bitmap(bitmap, render->rcvideo.l,
29+render->rcvideo.t,
render->rcvideo.r, render->rcvideo.b);
// printf("blit_bitmap\n");
 
delay(2);
 
render->target++;
render->target&= 3;
}
450,13 → 510,14
uint8_t *data[4];
int linesize[4];
 
if(render->win_state != NORMAL)
if(render->win_state == MINIMIZED ||
render->win_state == ROLLED)
return;
 
cvt_ctx = sws_getCachedContext(cvt_ctx,
render->ctx_width, render->ctx_height,
render->ctx_format,
render->win_width, render->win_height,
render->rcvideo.r, render->rcvideo.b,
PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);
if(cvt_ctx == NULL)
{
478,11 → 539,30
sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
picture->linesize, 0, render->ctx_height, data, linesize);
 
blit_bitmap(&render->bitmap[0], 5, 22,
render->win_width, render->win_height);
blit_bitmap(&render->bitmap[0], render->rcvideo.l,
render->rcvideo.t+29,
render->rcvideo.r, render->rcvideo.b);
}
 
void render_draw_client(render_t *render)
{
if(render->win_state == MINIMIZED ||
render->win_state == ROLLED)
return;
 
if(render->layout & HAS_TOP)
draw_bar(0, 29, render->win_width,
render->rctop.b, 0);
if(render->layout & HAS_LEFT)
draw_bar(0, render->rcvideo.t+29, render->rcleft.r,
render->rcvideo.b, 0);
if(render->layout & HAS_RIGHT)
draw_bar(render->rcright.l, render->rcvideo.t+29,
render->rcright.r, render->rcvideo.b, 0);
if(render->layout & HAS_BOTTOM)
draw_bar(0, render->rcbottom.t+29,
render->win_width, render->rcbottom.b, 0);
}