/programs/media/Fplay/audio.c |
---|
6,6 → 6,7 |
#include <stdio.h> |
#include <string.h> |
#include <winlib.h> |
#include "sound.h" |
#include "fplay.h" |
78,8 → 79,6 |
AVPacket pkt; |
AVPacket pkt_tmp; |
uint8_t *audio_data; |
int audio_size; |
int len; |
int data_size=0; |
/programs/media/Fplay/fplay.c |
---|
10,6 → 10,7 |
#include <string.h> |
#include <fcntl.h> |
#include <ctype.h> |
#include <winlib.h> |
#include "sound.h" |
#include "fplay.h" |
51,6 → 52,8 |
movie_file = argv[1]; |
/* register all codecs, demux and protocols */ |
// av_log_set_level(AV_LOG_INFO); |
avcodec_register_all(); |
avdevice_register_all(); |
av_register_all(); |
61,7 → 64,7 |
return -1; // Couldn't open file |
}; |
printf("%s\n\r", __FUNCTION__); |
// printf("%s\n\r", __FUNCTION__); |
// Retrieve stream information |
if(avformat_find_stream_info(pFormatCtx, NULL)<0) |
207,7 → 210,7 |
// __asm__ __volatile__("int3"); |
if(q_video.size+q_audio.size < 16*1024*1024) |
if(q_video.size+q_audio.size < 12*1024*1024) |
{ |
err = av_read_frame(pFormatCtx, &packet); |
if( err < 0) |
241,7 → 244,7 |
ret = 1; |
while(status != 0 && ret) |
while( (status != 0) && ret) |
{ |
ret = decode_video(pCodecCtx, &q_video); |
ret |= decode_audio(aCodecCtx, &q_audio); |
250,6 → 253,6 |
delay(50); |
status = 0; |
printf("status = 0\n"); |
delay(200); |
delay(300); |
}; |
/programs/media/Fplay/fplay.h |
---|
7,14 → 7,6 |
typedef struct |
{ |
int left; |
int top; |
int right; |
int bottom; |
}rect_t; |
typedef struct |
{ |
uint32_t width; |
uint32_t height; |
uint32_t pitch; |
24,6 → 16,11 |
typedef struct render render_t; |
#define HAS_LEFT (1<<0) |
#define HAS_TOP (1<<1) |
#define HAS_RIGHT (1<<2) |
#define HAS_BOTTOM (1<<3) |
struct render |
{ |
uint32_t caps; |
32,14 → 29,22 |
uint32_t win_width; |
uint32_t win_height; |
rect_t rc_client; |
rect_t rcvideo; |
rect_t rcleft; |
rect_t rctop; |
rect_t rcright; |
rect_t rcbottom; |
uint32_t layout; |
bitmap_t bitmap[4]; |
uint32_t ctx_format; |
int target; |
window_t *win; |
enum{ |
EMPTY, INIT }state; |
enum{ |
NORMAL, MINIMIZED, ROLLED |
}win_state; |
enum win_state win_state; |
void (*draw)(render_t *render, AVPicture *picture); |
}; |
90,8 → 95,11 |
uint32_t ctx_format, uint32_t flags); |
int init_render(render_t *render, int width, int height); |
void render_adjust_size(render_t *render); |
void render_adjust_size(render_t *render, window_t *win); |
int render_set_size(render_t *render, int width, int height); |
void render_draw_client(render_t *render); |
int init_audio(int format); |
int audio_thread(void *param); |
120,16 → 128,6 |
::"a"(68),"b"(14),"c"(event)); |
} |
static inline uint32_t check_os_event() |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(11)); |
return val; |
}; |
static inline uint32_t get_os_button() |
{ |
uint32_t val; |
154,49 → 152,9 |
::"a"(5), "b"(time)); |
}; |
static inline draw_bitmap(void *bitmap, int x, int y, int w, int h) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(7), "b"(bitmap), |
"c"((w << 16) | h), |
"d"((x << 16) | y)); |
} |
static inline void BeginDraw(void) |
{ |
__asm__ __volatile__( |
"int $0x40" ::"a"(12),"b"(1)); |
}; |
static inline void EndDraw(void) |
{ |
__asm__ __volatile__( |
"int $0x40" ::"a"(12),"b"(2)); |
}; |
static inline void DrawWindow(int x, int y, int w, int h, char *name, |
color_t workcolor, uint32_t style) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(0), |
"b"((x << 16) | (w & 0xFFFF)), |
"c"((y << 16) | (h & 0xFFFF)), |
"d"((style << 24) | (workcolor & 0xFFFFFF)), |
"D"(name)); |
}; |
static inline void get_proc_info(char *info) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(9), "b"(info), "c"(-1) |
:"memory"); |
} |
#define HW_BIT_BLIT (1<<0) /* BGRX blitter */ |
#define HW_TEX_BLIT (1<<1) /* stretch blit */ |
#define HW_VID_BLIT (1<<2) /* planar and packed video */ |
204,6 → 162,7 |
uint32_t InitPixlib(uint32_t flags); |
int create_bitmap(bitmap_t *bitmap); |
int lock_bitmap(bitmap_t *bitmap); |
int resize_bitmap(bitmap_t *bitmap); |
int blit_bitmap(bitmap_t *bitmap, int dst_x, int dst_y, |
int w, int h); |
/programs/media/Fplay/pixlib2.c |
---|
4,6 → 4,7 |
#include <libswscale/swscale.h> |
#include <stdio.h> |
#include <fcntl.h> |
#include <winlib.h> |
#include "fplay.h" |
#define DISPLAY_VERSION 0x0200 /* 2.00 */ |
12,6 → 13,8 |
#define SRV_GET_CAPS 3 |
#define SRV_CREATE_SURFACE 10 |
#define SRV_LOCK_SURFACE 12 |
#define SRV_BLIT_VIDEO 20 |
#define __ALIGN_MASK(x,mask) (((x)+(mask))&~(mask)) |
195,6 → 198,52 |
return -1; |
}; |
int lock_bitmap(bitmap_t *bitmap) |
{ |
// __asm__ __volatile__("int3"); |
if( 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 |
}io_12; |
ioctl_t io; |
int err; |
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(5); |
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 0; |
}; |
return err; |
}; |
return 0; |
}; |
struct blit_call |
{ |
int dstx; |
280,6 → 329,8 |
__asm__ __volatile__( |
"int $0x40" |
::"a"(73),"b"(0),"c"(&bc)); |
return 0; |
}; |
/programs/media/Fplay/system.h |
---|
0,0 → 1,311 |
#include <newlib.h> |
#include <stdint.h> |
#include <stddef.h> |
#ifdef CONFIG_DEBUF |
#define DBG(format,...) printf(format,##__VA_ARGS__) |
#else |
#define DBG(format,...) |
#endif |
typedef unsigned int color_t; |
typedef union __attribute__((packed)) |
{ |
uint32_t val; |
struct |
{ |
short x; |
short y; |
}; |
}pos_t; |
typedef union __attribute__((packed)) |
{ |
uint32_t val; |
struct |
{ |
uint8_t state; |
uint8_t code; |
uint16_t ctrl_key; |
}; |
}oskey_t; |
static inline |
void BeginDraw(void) |
{ |
__asm__ __volatile__( |
"int $0x40" ::"a"(12),"b"(1)); |
}; |
static inline |
void EndDraw(void) |
{ |
__asm__ __volatile__( |
"int $0x40" ::"a"(12),"b"(2)); |
}; |
static inline void DrawWindow(int x, int y, int w, int h, char *name, |
color_t workcolor, uint32_t style) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(0), |
"b"((x << 16) | (w & 0xFFFF)), |
"c"((y << 16) | (h & 0xFFFF)), |
"d"((style << 24) | (workcolor & 0xFFFFFF)), |
"D"(name)); |
}; |
static inline |
pos_t get_mouse_pos(void) |
{ |
pos_t val; |
__asm__ __volatile__( |
"int $0x40 \n\t" |
"rol $16, %%eax" |
:"=eax"(val) |
:"a"(37),"b"(1)); |
return val; |
} |
static inline |
pos_t get_cursor_pos(void) |
{ |
pos_t val; |
__asm__ __volatile__( |
"int $0x40 \n\t" |
"rol $16, %%eax" |
:"=eax"(val) |
:"a"(37),"b"(0)); |
return val; |
} |
static inline |
uint32_t get_mouse_buttons(void) |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(37),"b"(2)); |
return val; |
}; |
static inline |
uint32_t get_mouse_wheels(void) |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40 \n\t" |
"rol $16, %%eax" |
:"=a"(val) |
:"a"(37),"b"(7)); |
return val; |
}; |
static inline |
uint32_t wait_for_event(uint32_t time) |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(23), "b"(time)); |
return val; |
}; |
static inline uint32_t check_os_event() |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(11)); |
return val; |
}; |
static inline |
uint32_t get_tick_count(void) |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=eax"(val) |
:"a"(26),"b"(9)); |
return val; |
}; |
static inline |
oskey_t get_key(void) |
{ |
oskey_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=eax"(val) |
:"a"(2)); |
return val; |
} |
static inline |
void draw_line(int xs, int ys, int xe, int ye, color_t color) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(38), "d"(color), |
"b"((xs << 16) | xe), |
"c"((ys << 16) | ye)); |
} |
static inline |
void draw_bar(int x, int y, int w, int h, color_t color) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(13), "d"(color), |
"b"((x << 16) | w), |
"c"((y << 16) | h)); |
} |
static inline |
void draw_bitmap(void *bitmap, int x, int y, int w, int h) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(7), "b"(bitmap), |
"c"((w << 16) | h), |
"d"((x << 16) | y)); |
} |
static inline |
void draw_text(const char *text, int x, int y, int len, color_t color) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(4),"d"(text), |
"b"((x << 16) | y), |
"S"(len),"c"(color)); |
} |
static inline |
void *user_alloc(size_t size) |
{ |
void *val; |
__asm__ __volatile__( |
"int $0x40" |
:"=eax"(val) |
:"a"(68),"b"(12),"c"(size)); |
return val; |
} |
static inline |
int user_free(void *mem) |
{ |
int val; |
__asm__ __volatile__( |
"int $0x40" |
:"=eax"(val) |
:"a"(68),"b"(12),"c"(mem)); |
return val; |
} |
static inline |
int *user_unmap(void *base, size_t offset, size_t size) |
{ |
void *val; |
__asm__ __volatile__( |
"int $0x40" |
:"=eax"(val) |
:"a"(68),"b"(26),"c"(base),"d"(offset),"S"(size)); |
return val; |
} |
/* |
extern inline |
void exit(int status) __attribute__((noreturn)) ; |
extern inline |
void exit(int status) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(-1)); |
for(;;); |
} |
*/ |
static inline |
uint32_t load_cursor(void *path, uint32_t flags) |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=eax"(val) |
:"a"(37), "b"(4), "c"(path), "d"(flags)); |
return val; |
} |
static inline |
uint32_t set_cursor(uint32_t cursor) |
{ |
uint32_t old; |
__asm__ __volatile__( |
"int $0x40" |
:"=eax"(old) |
:"a"(37), "b"(5), "c"(cursor)); |
return old; |
} |
static inline void get_proc_info(char *info) |
{ |
__asm__ __volatile__( |
"int $0x40" |
: |
:"a"(9), "b"(info), "c"(-1)); |
} |
static inline |
void* user_realloc(void *mem, size_t size) |
{ |
void *val; |
__asm__ __volatile__( |
"int $0x40" |
:"=eax"(val) |
:"a"(68),"b"(12),"c"(size),"d"(mem) |
:"memory"); |
return val; |
} |
void *load_file(const char *path, size_t *len); |
void *get_resource(void *data, uint32_t id); |
struct blit_call |
{ |
int dstx; |
int dsty; |
int w; |
int h; |
int srcx; |
int srcy; |
int srcw; |
int srch; |
unsigned char *bitmap; |
int stride; |
}; |
void Blit(void *bitmap, int dst_x, int dst_y, |
int src_x, int src_y, int w, int h, |
int src_w, int src_h, int stride); |
/programs/media/Fplay/utils.c |
---|
5,6 → 5,7 |
#include <libswscale/swscale.h> |
#include <stdio.h> |
#include <fcntl.h> |
#include <winlib.h> |
#include "fplay.h" |
extern uint32_t hw2d ; |
/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); |
} |