WebSVN – Kolibri OS – Blame – /contrib/media/fplay/video.c

Rev	Author	Line No.	Line
4438	Serge	1
		2	#include
		3	#include
		4	#include
		5	#include
		6	#include
6106	serge	7	#include
4438	Serge	8	#include
6106	serge	9
		10
5021	Serge	11	#include "fplay.h"
4438	Serge	12
		13
		14	extern int res_pause_btn_pressed[];
		15
		16
		17	extern int res_play_btn_pressed[];
		18
		19
		20	extern volatile int sound_level_0;
		21	extern volatile int sound_level_1;
		22
		23
		24
		25
		26
		27
		28	void run_render(window_t win, void render);
6133	serge	29	void window_update_layout(window_t *win);
		30	int fini_winlib();
		31
4438	Serge	32
6118	serge	33	{
4438	Serge	34	vframe_t vframe, tmp;
6133	serge	35
4438	Serge	36
6133	serge	37	mutex_lock(&vst->input_lock);
		38
		39
		40	list_move_tail(&vframe->list, &vst->input_list);
		41
		42
6144	serge	43	{
4438	Serge	44	vframe->pts = 0;
6133	serge	45	vframe->ready = 0;
		46	}
		47	vst->frames_count = 0;
6136	serge	48
6133	serge	49
		50	mutex_unlock(&vst->output_lock);
		51	};
4438	Serge	52
		53
		54
6135	serge	55
4438	Serge	56	extern volatile enum player_state decoder_state;
		57	extern volatile enum player_state sound_state;
		58
		59
		60
		61
		62	{
		63	window_t *win;
		64
		65
		66
		67
		68
		69
		70	win->panel.play_btn->img_hilite = res_play_btn;
		71	win->panel.play_btn->img_pressed = res_play_btn_pressed;
		72	win->panel.prg->current = rewind_pos;
		73
		74
		75	player_state = STOP;
		76	decoder_state = PLAY_2_STOP;
		77	sound_state = PLAY_2_STOP;
		78	render_draw_client(main_render);
		79	};
		80
		81
		82	{
		83	window_t win = (window_t)ctrl;
		84	static int spc_down = 0;
		85	static int ent_down = 0;
		86
		87
		88	{
		89	case MSG_SIZE:
		90	if(main_render)
		91	{
		92	render_adjust_size(main_render, win);
		93	render_draw_client(main_render);
		94	};
		95	break;
		96
		97
		98	switch((short)arg2)
		99	{
		100	case 0x39:
		101	if(spc_down == 0)
		102	{
		103	spc_down = 1;
		104	send_message(win, MSG_LBTNDOWN, 0, 0);
		105	}
		106	break;
		107
		108
		109	spc_down = 0;
		110	break;
		111
		112
		113	if(ent_down == 0)
		114	{
		115	int screensize;
		116	if(win->win_state == NORMAL)
		117	{
		118	win->saved = win->rc;
		119	win->saved_state = win->win_state;
		120
		121
		122	__asm__ __volatile__(
		123	"int $0x40"
		124	::"a"(67), "b"(0), "c"(0),
		125	"d"((screensize >> 16)-1),"S"((screensize & 0xFFFF)-1) );
		126	win->win_state = FULLSCREEN;
		127	window_update_layout(win);
		128	}
		129	else if(win->win_state == FULLSCREEN)
		130	{
		131	__asm__ __volatile__(
		132	"int $0x40"
		133	::"a"(67), "b"(win->saved.l), "c"(win->saved.t),
		134	"d"(win->saved.r-win->saved.l-1),"S"(win->saved.b-win->saved.t-1));
		135	win->win_state = win->saved_state;
		136	window_update_layout(win);
		137	// if(win->saved_state == MAXIMIZED)
		138	// {
5372	serge	139	// blit_caption(&win->caption);
		140	// blit_panel(&win->panel);
		141	// }
		142	}
4438	Serge	143	ent_down = 1;
		144	};
		145	break;
		146
		147
		148	ent_down = 0;
		149	break;
		150	};
		151
		152
		153	if(main_render)
		154	{
		155	render_draw_client(main_render);
		156	};
		157	break;
		158
		159
		160
		161
		162	{
		163	win->panel.play_btn->img_default = res_pause_btn;
		164	win->panel.play_btn->img_hilite = res_pause_btn;
		165	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
		166	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
		167	player_state = PLAY;
		168	sound_state = PAUSE_2_PLAY;
		169
		170
		171	else if(player_state == PLAY)
		172	{
		173	win->panel.play_btn->img_default = res_play_btn;
		174	win->panel.play_btn->img_hilite = res_play_btn;
		175	win->panel.play_btn->img_pressed = res_play_btn_pressed;
		176	send_message(&win->panel.play_btn->ctrl, MSG_PAINT, 0, 0);
		177	player_state = PAUSE;
		178	sound_state = PLAY_2_PAUSE;
		179	}
		180	break;
		181
		182
		183	switch((short)arg1)
		184	{
		185	case ID_PLAY:
		186	if(player_state == PAUSE)
		187	{
		188	win->panel.play_btn->img_default = res_pause_btn;
		189	win->panel.play_btn->img_hilite = res_pause_btn;
		190	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
		191	player_state = PLAY;
		192	sound_state = PAUSE_2_PLAY;
		193	}
		194	else if(player_state == PLAY)
		195	{
		196	win->panel.play_btn->img_default = res_play_btn;
		197	win->panel.play_btn->img_hilite = res_play_btn;
		198	win->panel.play_btn->img_pressed = res_play_btn_pressed;
		199	player_state = PAUSE;
		200	sound_state = PLAY_2_PAUSE;
		201	}
		202	else if(player_state == STOP)
		203	{
		204	win->panel.play_btn->img_default = res_pause_btn;
		205	win->panel.play_btn->img_hilite = res_pause_btn;
		206	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
		207	rewind_pos = 0;
		208	send_message(&win->panel.ctrl, MSG_PAINT, 0, 0);
		209	player_state = PLAY;
		210	decoder_state = PREPARE;
		211	}
		212	break;
		213
		214
		215	player_stop();
		216	break;
		217
		218
		219	if(player_state != REWIND)
		220	{
		221	progress_t prg = (progress_t)arg2;
		222
		223
		224
		225
		226	decoder_state = REWIND;
		227	sound_state = PLAY_2_STOP;
		228	if(rewind_pos < prg->current)
		229	{
		230	prg->current = rewind_pos;
		231	rewind_pos = -rewind_pos;
		232	}
		233	else
		234	prg->current = rewind_pos;
		235
		236
		237	win->panel.play_btn->img_hilite = res_pause_btn;
		238	win->panel.play_btn->img_pressed = res_pause_btn_pressed;
		239	send_message(&prg->ctrl, MSG_PAINT, 0, 0);
		240	};
		241	break;
		242
		243
		244	{
		245	slider_t sld = (slider_t)arg2;
		246	int peak;
		247	int level;
		248
		249
		250	level = peak;
		251
		252
		253	send_message(&sld->ctrl, MSG_PAINT, 0, 0);
		254	win->panel.lvl->vol = level;
		255	}
		256
		257
		258	break;
		259	}
		260	break;
		261
		262
		263	def_window_proc(ctrl,msg,arg1,arg2);
		264	};
		265	return 0;
		266	};
		267
		268
		269	{
		270	progress_t *prg = main_render->win->panel.prg;
6118	serge	271	level_t *lvl = main_render->win->panel.lvl;
		272	vst_t *vst = main_render->vst;
		273	double ctime; /* milliseconds */
4438	Serge	274	double fdelay; /* milliseconds */
		275
		276
		277	{
		278	render->win->win_command = WIN_CLOSED;
		279	return;
		280	}
		281	else if((player_state == PAUSE) \|\| (player_state == REWIND))
		282	{
		283	delay(1);
		284	return;
		285	}
		286	else if (decoder_state == STOP && vst->frames_count == 0 &&
6136	serge	287	player_state != STOP)
4438	Serge	288	{
		289	player_stop();
		290	}
		291	else if(player_state != PLAY)
		292	{
		293	delay(1);
		294	return;
		295	};
		296
		297
6133	serge	298	if(list_empty(&vst->output_list))
		299	{
4438	Serge	300	mutex_unlock(&vst->output_lock);
6133	serge	301	delay(1);
		302	}
		303	else
		304	{
		305	vframe_t *vframe;
		306	int sys_time;
4438	Serge	307
		308
6133	serge	309	list_del(&vframe->list);
		310	vst->frames_count--;
6136	serge	311	mutex_unlock(&vst->output_lock);
6133	serge	312
		313
4438	Serge	314	fdelay = (vframe->pts - ctime);
6136	serge	315
4438	Serge	316
		317	{
		318	delay((int)fdelay/10);
		319	};
		320
		321
6133	serge	322	// vframe->index,vframe->pts,vframe->pkt_pts,vframe->pkt_dts);
		323
4438	Serge	324
6133	serge	325
4438	Serge	326
		327	{
		328	prg->current = vframe->pts * 1000;
6136	serge	329	lvl->current = vframe->index & 1 ? sound_level_1 : sound_level_0;
6133	serge	330
4438	Serge	331
		332
		333
		334	send_message(&lvl->ctrl, MSG_PAINT, 0, 0);
		335	}
		336
		337
6133	serge	338
4438	Serge	339
6133	serge	340	list_add_tail(&vframe->list, &vst->input_list);
		341	mutex_unlock(&vst->input_lock);
		342	}
4438	Serge	343	}
		344
		345
		346	{
		347	vst_t *vst = param;
6117	serge	348	window_t *MainWindow;
4438	Serge	349
		350
		351
		352
6136	serge	353	10,10,vst->vCtx->width,vst->vCtx->height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
6133	serge	354
4438	Serge	355
		356
		357
		358
		359
6117	serge	360	if( main_render == NULL)
4438	Serge	361	{
		362	mutex_unlock(&vst->decoder_lock);
6133	serge	363	printf("Cannot create render\n\r");
4438	Serge	364	return 0;
		365	};
		366
		367
5603	serge	368
		369
4438	Serge	370	player_state = PLAY;
		371
		372
6133	serge	373
		374
4438	Serge	375
		376
5603	serge	377
		378
6144	serge	379	vframe_t vframe, tmp;
		380	flush_video(vst);
		381
		382
		383	{
		384	list_del(&vframe->list);
		385	if(vframe->planar != NULL)
		386	pxDestroyPlanar(vframe->planar);
		387	}
		388	}
		389
		390
4438	Serge	391	fini_winlib();
		392	player_state = CLOSED;
		393	return 0;
		394	};
		395
		396
		397
6133	serge	398	void draw_sw_picture(render_t render, vframe_t vframe);
		399
4438	Serge	400
6117	serge	401	{
4438	Serge	402	render_t *render;
		403
		404
		405	uint32_t s, sw, sh;
		406	uint8_t state;
		407
		408
		409
		410
		411	memset(render, 0, sizeof(render_t));
		412
		413
6117	serge	414	render->win = win;
4438	Serge	415
		416
6117	serge	417	render->ctx_height = vst->vCtx->height;
		418	render->ctx_format = vst->vCtx->pix_fmt;
		419
4438	Serge	420
5372	serge	421
4438	Serge	422
		423	bottom = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
		424
		425
5372	serge	426	right, bottom);
		427
4438	Serge	428
		429
		430
		431	draw_h = right*render->ctx_height/render->ctx_width;
		432
		433
		434	{
		435	draw_w = right;
		436	draw_h = right*render->ctx_height/render->ctx_width;
		437	};
		438
		439
		440	{
		441	draw_h = bottom;
		442	draw_w = bottom*render->ctx_width/render->ctx_height;
		443	};
		444
		445
		446	render->win_height = win->h-CAPTION_HEIGHT-PANEL_HEIGHT;
		447
		448
		449
		450
5372	serge	451
4438	Serge	452
		453	{
		454	render->bitmap[0] = pxCreateBitmap(draw_w, draw_h);
5372	serge	455	if(render->bitmap[0] == NULL)
		456	{
4438	Serge	457	free(render);
		458	return NULL;
		459	}
		460	render->draw = draw_sw_picture;
		461	}
		462	else
		463	{
		464	int width, height;
5372	serge	465	int i;
4438	Serge	466
		467
		468	{
		469	width = render->ctx_width;
		470	height = render->ctx_height;
		471	}
		472	else
		473	{
		474	width = draw_w;
		475	height = draw_h;;
		476	}
		477
		478
		479	{
		480	render->bitmap[i] = pxCreateBitmap(width, height);
5372	serge	481	if( render->bitmap[i] == NULL )
		482	{
4438	Serge	483	player_state = CLOSED;
		484	free(render);
		485	return NULL;
		486	};
		487	}
		488
		489
		490	render->target = 0;
		491	render->draw = draw_hw_picture;
		492	};
		493
		494
		495	render->caps & HW_TEX_BLIT ? "hw_tex_blit":
		496	render->caps & HW_BIT_BLIT ? "hw_bit_blit":"software",
		497	render->ctx_width, render->ctx_height,
		498	draw_w, draw_h);
		499
		500
		501	};
		502
		503
		504	{
		505
		506
5372	serge	507
4438	Serge	508
		509	pxDestroyBitmap(render->bitmap[1]);
5372	serge	510
4438	Serge	511
5372	serge	512	};
4438	Serge	513
		514
		515	{
		516	int i;
		517
		518
		519	render->rcvideo.l = 0;
		520	render->rcvideo.t = 0;
		521	render->rcvideo.r = width;
		522	render->rcvideo.b = height;
		523
		524
		525
		526
		527	{
		528	int yoffs;
		529	yoffs = (render->win_height-height)/2;
		530	if(yoffs)
		531	{
		532	render->rctop.t = 0;
		533	render->rctop.b = yoffs;
		534	render->rcvideo.t = yoffs;
		535	render->layout \|= HAS_TOP;
		536	}
		537
		538
		539	if(yoffs)
		540	{
		541	render->rcbottom.t = render->rcvideo.t+render->rcvideo.b;
		542	render->rcbottom.b = yoffs;
		543	render->layout \|= HAS_BOTTOM;
		544	}
		545	}
		546
		547
		548	{
		549	int xoffs;
		550	xoffs = (render->win_width-width)/2;
		551	if(xoffs)
		552	{
		553	render->rcleft.r = xoffs;
		554	render->rcvideo.l = xoffs;
		555	render->layout \|= HAS_LEFT;
		556	}
		557	xoffs = render->win_width-(render->rcvideo.l+render->rcvideo.r);
		558	if(xoffs)
		559	{
		560	render->rcright.l = render->rcvideo.l+render->rcvideo.r;
		561	render->rcright.r = xoffs;
		562	render->layout \|= HAS_RIGHT;
		563	}
		564	};
		565	};
		566
		567
		568	{
		569	uint32_t right, bottom, new_w, new_h;
		570	uint32_t s, sw, sh;
		571	uint8_t state;
		572
		573
		574	bottom = win->h;
		575
		576
		577	bottom-= CAPTION_HEIGHT+PANEL_HEIGHT;
		578
		579
		580	// right, bottom);
		581
		582
		583
		584
		585	return;
		586
		587
		588	return;
		589
		590
		591	bottom == render->win_height)
		592	return;
		593
		594
		595
		596
		597	new_h = right*render->ctx_height/render->ctx_width;
		598
		599
		600	{
		601	new_w = right;
		602	new_h = right*render->ctx_height/render->ctx_width;
		603	};
		604	if(new_h > bottom)
		605	{
		606	new_h = bottom;
		607	new_w = bottom*render->ctx_width/render->ctx_height;
		608	};
		609
		610
		611	render->win_height = bottom;
		612	render_set_size(render, new_w, new_h);
		613
		614
		615	{
5372	serge	616	if(render->win->win_state == FULLSCREEN)
		617	pxResizeClient(render->rcvideo.l, render->rcvideo.t, new_w, new_h);
		618	else
		619	pxResizeClient(render->rcvideo.l, render->rcvideo.t+CAPTION_HEIGHT, new_w, new_h);
		620
		621
4438	Serge	622	};
5372	serge	623
4438	Serge	624
5372	serge	625
4438	Serge	626
		627	pxResizeBitmap(render->bitmap[1], new_w, new_h);
5372	serge	628
		629
4438	Serge	630	};
		631
		632
6133	serge	633	{
4438	Serge	634	vst_t *vst = render->vst;
6133	serge	635	planar_t *planar = vframe->planar;
		636
		637
		638	{
		639	mutex_lock(&render->vst->gpu_lock);
		640
		641
		642	CAPTION_HEIGHT+render->rcvideo.t,
		643	render->rcvideo.r, render->rcvideo.b,0,0);
		644	mutex_unlock(&render->vst->gpu_lock);
		645	}
		646	};
		647
		648
		649	{
		650	AVPicture *picture;
		651	int dst_width;
5372	serge	652	int dst_height;
		653	bitmap_t *bitmap;
		654	uint8_t *bitmap_data;
		655	uint32_t bitmap_pitch;
		656	uint8_t *data[4];
		657	int linesize[4];
		658	enum AVPixelFormat format;
6121	serge	659
4438	Serge	660
6133	serge	661
		662
4438	Serge	663	render->win->win_state == ROLLED)
		664	return;
		665
		666
		667	{
		668	dst_width = render->ctx_width;
		669	dst_height = render->ctx_height;
		670	}
		671	else
		672	{
		673	dst_width = render->rcvideo.r;
		674	dst_height = render->rcvideo.b;
		675	};
		676
		677
6144	serge	678	{
6133	serge	679	render_hw_planar(render, vframe);
		680	return;
		681	};
		682
		683
		684
		685
6144	serge	686	cvt_ctx = sws_getCachedContext(cvt_ctx, render->ctx_width, render->ctx_height, format,
6133	serge	687	dst_width, dst_height, AV_PIX_FMT_BGRA,
		688	SWS_FAST_BILINEAR, NULL, NULL, NULL);
		689	if(cvt_ctx == NULL)
4438	Serge	690	{
		691	printf("Cannot initialize the conversion context!\n");
		692	return ;
		693	};
		694
		695
5372	serge	696
4438	Serge	697
5372	serge	698	if( bitmap_data == NULL)
		699	{
4438	Serge	700	printf("Cannot lock bitmap!\n");
		701	return ;
		702	}
		703
		704
5372	serge	705	data[1] = bitmap_data+1;
		706	data[2] = bitmap_data+2;
		707	data[3] = bitmap_data+3;
		708
4438	Serge	709
5372	serge	710	linesize[1] = bitmap_pitch;
		711	linesize[2] = bitmap_pitch;
		712	linesize[3] = bitmap_pitch;
		713
4438	Serge	714
		715	picture->linesize, 0, render->ctx_height, data, linesize);
		716	// printf("sws_scale\n");
		717
		718
6117	serge	719
4438	Serge	720
		721	{
		722
		723
		724	pxBlitBitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
5372	serge	725	render->rcvideo.r, render->rcvideo.b,0,0);
		726	else
4438	Serge	727	pxBlitBitmap(bitmap, render->rcvideo.l,
5372	serge	728	CAPTION_HEIGHT+render->rcvideo.t,
4438	Serge	729	render->rcvideo.r, render->rcvideo.b,0,0);
5372	serge	730	}
4438	Serge	731	else
		732	{
		733	if(render->win->win_state == FULLSCREEN)
		734	pxBlitBitmap(bitmap,render->rcvideo.l,render->rcvideo.t,
5372	serge	735	render->rcvideo.r, render->rcvideo.b, 0,0);
4438	Serge	736	else
		737	pxBlitBitmap(bitmap, render->rcvideo.l,
5372	serge	738	CAPTION_HEIGHT+render->rcvideo.t,
4438	Serge	739	render->rcvideo.r, render->rcvideo.b, 0, 0);
		740	};
		741	mutex_unlock(&render->vst->gpu_lock);
6117	serge	742
4438	Serge	743
		744	render->target++;
		745	render->target&= 1;
		746	}
		747
		748
6133	serge	749	{
4438	Serge	750	AVPicture *picture;
6133	serge	751	uint8_t *bitmap_data;
5372	serge	752	uint32_t bitmap_pitch;
		753	uint8_t *data[4];
6118	serge	754	int linesize[4];
4438	Serge	755
		756
		757	render->win->win_state == ROLLED)
		758	return;
		759
		760
6133	serge	761
		762
4438	Serge	763	render->ctx_width, render->ctx_height,
		764	render->ctx_format,
		765	render->rcvideo.r, render->rcvideo.b,
		766	AV_PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);
6117	serge	767	if(cvt_ctx == NULL)
4438	Serge	768	{
		769	printf("Cannot initialize the conversion context!\n");
		770	return ;
		771	}
		772
		773
5372	serge	774
4438	Serge	775
5372	serge	776	data[1] = bitmap_data+1;
		777	data[2] = bitmap_data+2;
		778	data[3] = bitmap_data+3;
		779
4438	Serge	780
5372	serge	781	linesize[1] = bitmap_pitch;
		782	linesize[2] = bitmap_pitch;
		783	linesize[3] = bitmap_pitch;
		784
4438	Serge	785
		786	picture->linesize, 0, render->ctx_height, data, linesize);
		787
		788
		789	pxBlitBitmap(render->bitmap[0],render->rcvideo.l,render->rcvideo.t,
5372	serge	790	render->rcvideo.r, render->rcvideo.b,0,0);
		791	else
4438	Serge	792	pxBlitBitmap(render->bitmap[0], render->rcvideo.l,
5372	serge	793	CAPTION_HEIGHT+render->rcvideo.t,
4438	Serge	794	render->rcvideo.r, render->rcvideo.b,0,0);
5372	serge	795
4438	Serge	796
5372	serge	797	}
4438	Serge	798
		799
		800	{
		801	vst_t *vst = render->vst;
6118	serge	802	int y;
4438	Serge	803
		804
		805	render->win_state == ROLLED )
		806	return;
		807	if(render->win_state == FULLSCREEN)
		808	y = 0;
		809	else
		810	y = CAPTION_HEIGHT;
		811
		812
		813	{
		814	// if(vst->vframe[vst->vfx].ready == 1 )
6133	serge	815	// main_render->draw(main_render, &vst->vframe[vst->vfx].picture);
		816	// else
		817	draw_bar(0, y, render->win_width,
4438	Serge	818	render->rcvideo.b, 0);
		819	}
		820	else if( player_state == STOP )
		821	{
		822	draw_bar(0,y, render->win_width,
		823	render->rcvideo.b, 0);
		824	};
		825
		826
		827	draw_bar(0, y, render->win_width,
		828	render->rctop.b, 0);
		829	if(render->layout & HAS_LEFT)
		830	draw_bar(0, render->rcvideo.t+y, render->rcleft.r,
		831	render->rcvideo.b, 0);
		832	if(render->layout & HAS_RIGHT)
		833	draw_bar(render->rcright.l, render->rcvideo.t+y,
		834	render->rcright.r, render->rcvideo.b, 0);
		835	if(render->layout & HAS_BOTTOM)
		836	draw_bar(0, render->rcbottom.t+y,
		837	render->win_width, render->rcbottom.b, 0);
		838	}
		839

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/video.c – Rev 6144