WebSVN – Kolibri OS – Diff – /contrib/media/fplay/fplay.h


 
#include 
#include "pixlib3.h"
 
#define BLACK_MAGIC_SOUND
#define BLACK_MAGIC_VIDEO
 
typedef unsigned int color_t;
typedef unsigned int count_t;
 
typedef struct render  render_t;
typedef struct vstate vst_t;
 
#define HAS_LEFT        (1<<0)
#define HAS_TOP         (1<<1)
#define HAS_RIGHT       (1<<2)
#define HAS_BOTTOM      (1<<3)
 
struct render
{
    vst_t     *vst;
    uint32_t   caps;
    uint32_t   ctx_width;
    uint32_t   ctx_height;
    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];
    bitmap_t  *last_bitmap;
 
    uint32_t   ctx_format;
    int        target;
 
    window_t   *win;
    enum{
      EMPTY, INIT }state;
    enum win_state win_state;
 
    void (*draw)(render_t *render, AVPicture *picture);
};
 
enum player_state
{
    CLOSED = 0,
    PREPARE,
    STOP,
    PAUSE,
    PLAY,
    REWIND,
    PLAY_2_STOP,
    PLAY_2_PAUSE,
    PAUSE_2_PLAY,
    REWIND_2_PLAY,
};
 
#define ID_PLAY             100
#define ID_STOP             101
#define ID_PROGRESS         102
#define ID_VOL_LEVEL        103
#define ID_VOL_CTRL         104
 
 
typedef struct
{
    mutex_t lock;
    char    *buffer;
    int     count;
}astream_t;
 
typedef struct
{
  unsigned int  code;
  unsigned int  sender;
  unsigned int  stream;
  unsigned int  offset;
  unsigned int  size;
  unsigned int  unused[2];
}SND_EVENT;
 
 
typedef struct {
    AVPacketList *first_pkt;
    AVPacketList *last_pkt;
    int size;
    int count;
    mutex_t       lock;
} queue_t;
 
int put_packet(queue_t *q, AVPacket *pkt);
int get_packet(queue_t *q, AVPacket *pkt);
 
struct vstate
{
    AVFormatContext *fCtx;      /* format context */
    AVCodecContext  *vCtx;      /* video decoder context */
    AVCodecContext  *aCtx;      /* audio decoder context */
    AVCodec         *vCodec;    /* video codec */
    AVCodec         *aCodec;    /* audio codec */
    int             vStream;    /* video stream index */
    int             aStream;    /* audio stream index */
 
    queue_t         q_video;    /* video packets queue */
    queue_t         q_audio;    /* audio packets queue */
 
    mutex_t         gpu_lock;   /* gpu access lock. libdrm not yet thread safe :( */
 
};
 
 
 
#define DECODER_THREAD  1
#define AUDIO_THREAD    2
#define VIDEO_THREAD    4
 
extern int threads_running;
extern astream_t astream;
extern AVRational video_time_base;
 
render_t *create_render(vst_t *vst, window_t *win, uint32_t flags);
void destroy_render(render_t *render);
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);
void render_draw_client(render_t *render);
 
 
int init_audio(int format);
int audio_thread(void *param);
void set_audio_volume(int left, int right);
 
int init_video(vst_t* vst);
int video_thread(void *param);
 
void decoder(vst_t *vst);
int decode_video(vst_t* vst);
int decode_audio(AVCodecContext  *ctx, queue_t *qa);
 
double get_master_clock(void);
 
static inline void GetNotify(void *event)
{
    __asm__ __volatile__ (
    "int $0x40"
    ::"a"(68),"b"(14),"c"(event));
}
 
int fplay_vaapi_init(void);
int init_fontlib();
char *get_moviefile();
 
struct>
 
struct>
#define>
#define>
#define>
#define>
#define>
#define>

Rev 6106	Rev 6117
1	#include "pixlib3.h"	-
2	#include	1	#include
-		2	#include "pixlib3.h"
3		3
4	#define BLACK_MAGIC_SOUND	4	#define BLACK_MAGIC_SOUND
5	#define BLACK_MAGIC_VIDEO	5	#define BLACK_MAGIC_VIDEO
6		6
7	typedef unsigned int color_t;	7	typedef unsigned int color_t;
8	typedef unsigned int count_t;	8	typedef unsigned int count_t;
9		9
10	typedef struct render render_t;	10	typedef struct render render_t;
11		11	typedef struct vstate vst_t;
-		12
12	#define HAS_LEFT (1<<0)	13	#define HAS_LEFT (1<<0)
13	#define HAS_TOP (1<<1)	14	#define HAS_TOP (1<<1)
14	#define HAS_RIGHT (1<<2)	15	#define HAS_RIGHT (1<<2)
15	#define HAS_BOTTOM (1<<3)	16	#define HAS_BOTTOM (1<<3)
16		17
17	struct render	18	struct render
18	{	19	{
19	uint32_t caps;	20	vst_t *vst;
-		21	uint32_t caps;
20	uint32_t ctx_width;	22	uint32_t ctx_width;
21	uint32_t ctx_height;	23	uint32_t ctx_height;
22	uint32_t win_width;	24	uint32_t win_width;
23	uint32_t win_height;	25	uint32_t win_height;
24		26
25	rect_t rc_client;	27	rect_t rc_client;
26	rect_t rcvideo;	28	rect_t rcvideo;
27	rect_t rcleft;	29	rect_t rcleft;
28	rect_t rctop;	30	rect_t rctop;
29	rect_t rcright;	31	rect_t rcright;
30	rect_t rcbottom;	32	rect_t rcbottom;
31		33
32	uint32_t layout;	34	uint32_t layout;
33	bitmap_t *bitmap[4];	35	bitmap_t *bitmap[4];
34	bitmap_t *last_bitmap;	36	bitmap_t *last_bitmap;
35		37
36	uint32_t ctx_format;	38	uint32_t ctx_format;
37	int target;	39	int target;
38		40
39	window_t *win;	41	window_t *win;
40	enum{	42	enum{
41	EMPTY, INIT }state;	43	EMPTY, INIT }state;
42	enum win_state win_state;	44	enum win_state win_state;
43		45
44	void (draw)(render_t render, AVPicture *picture);	46	void (draw)(render_t render, AVPicture *picture);
45	};	47	};
46		48
47	enum player_state	49	enum player_state
48	{	50	{
49	CLOSED = 0,	51	CLOSED = 0,
50	PREPARE,	52	PREPARE,
51	STOP,	53	STOP,
52	PAUSE,	54	PAUSE,
53	PLAY,	55	PLAY,
54	REWIND,	56	REWIND,
55	PLAY_2_STOP,	57	PLAY_2_STOP,
56	PLAY_2_PAUSE,	58	PLAY_2_PAUSE,
57	PAUSE_2_PLAY,	59	PAUSE_2_PLAY,
58	REWIND_2_PLAY,	60	REWIND_2_PLAY,
59	};	61	};
60		62
61	#define ID_PLAY 100	63	#define ID_PLAY 100
62	#define ID_STOP 101	64	#define ID_STOP 101
63	#define ID_PROGRESS 102	65	#define ID_PROGRESS 102
64	#define ID_VOL_LEVEL 103	66	#define ID_VOL_LEVEL 103
65	#define ID_VOL_CTRL 104	67	#define ID_VOL_CTRL 104
66		68
67		-
68	typedef struct	69	typedef struct
69	{	70	{
70	mutex_t lock;	71	mutex_t lock;
71	char *buffer;	72	char *buffer;
72	int count;	73	int count;
73	}astream_t;	74	}astream_t;
74		75
75	typedef struct	76	typedef struct
76	{	77	{
77	unsigned int code;	78	unsigned int code;
78	unsigned int sender;	79	unsigned int sender;
79	unsigned int stream;	80	unsigned int stream;
80	unsigned int offset;	81	unsigned int offset;
81	unsigned int size;	82	unsigned int size;
82	unsigned int unused[2];	83	unsigned int unused[2];
83	}SND_EVENT;	84	}SND_EVENT;
84		85
85		86
86	typedef struct {	87	typedef struct {
87	AVPacketList *first_pkt;	88	AVPacketList *first_pkt;
88	AVPacketList *last_pkt;	89	AVPacketList *last_pkt;
89	int size;	90	int size;
90	int count;	91	int count;
91	mutex_t lock;	92	mutex_t lock;
92	} queue_t;	93	} queue_t;
93		94
94	int put_packet(queue_t q, AVPacket pkt);	95	int put_packet(queue_t q, AVPacket pkt);
95	int get_packet(queue_t q, AVPacket pkt);	96	int get_packet(queue_t q, AVPacket pkt);
96		97
-		98	struct vstate
-		99	{
-		100	AVFormatContext fCtx; / format context */
-		101	AVCodecContext vCtx; / video decoder context */
-		102	AVCodecContext aCtx; / audio decoder context */
-		103	AVCodec vCodec; / video codec */
-		104	AVCodec aCodec; / audio codec */
-		105	int vStream; /* video stream index */
-		106	int aStream; /* audio stream index */
-		107
-		108	queue_t q_video; /* video packets queue */
-		109	queue_t q_audio; /* audio packets queue */
-		110
-		111	mutex_t gpu_lock; /* gpu access lock. libdrm not yet thread safe :( */
-		112
-		113	};
-		114
-		115
97		116
98	#define DECODER_THREAD 1	117	#define DECODER_THREAD 1
99	#define AUDIO_THREAD 2	118	#define AUDIO_THREAD 2
100	#define VIDEO_THREAD 4	119	#define VIDEO_THREAD 4
101		120
102	extern int threads_running;	121	extern int threads_running;
103	extern astream_t astream;	122	extern astream_t astream;
104	extern AVRational video_time_base;	123	extern AVRational video_time_base;
105		124
106	render_t create_render(window_t win, AVCodecContext *ctx, uint32_t flags);	125	render_t create_render(vst_t vst, window_t *win, uint32_t flags);
107	void destroy_render(render_t *render);	126	void destroy_render(render_t *render);
108	int init_render(render_t *render, int width, int height);	127	int init_render(render_t *render, int width, int height);
109	void render_adjust_size(render_t render, window_t win);	128	void render_adjust_size(render_t render, window_t win);
110	void render_set_size(render_t *render, int width, int height);	129	void render_set_size(render_t *render, int width, int height);
111	void render_draw_client(render_t *render);	130	void render_draw_client(render_t *render);
112		131
113		132
114	int init_audio(int format);	133	int init_audio(int format);
115	int audio_thread(void *param);	134	int audio_thread(void *param);
116	void set_audio_volume(int left, int right);	135	void set_audio_volume(int left, int right);
117		136
118	int init_video(AVCodecContext *ctx);	137	int init_video(vst_t* vst);
119	int video_thread(void *param);	138	int video_thread(void *param);
-		139
120		140	void decoder(vst_t *vst);
121	int decode_video(AVCodecContext ctx, queue_t qv);	141	int decode_video(vst_t* vst);
122	int decode_audio(AVCodecContext ctx, queue_t qa);	142	int decode_audio(AVCodecContext ctx, queue_t qa);
123		143
124	double get_master_clock(void);	144	double get_master_clock(void);
125		145
126	static inline void GetNotify(void *event)	146	static inline void GetNotify(void *event)
127	{	147	{
128	__asm__ __volatile__ (	148	__asm__ __volatile__ (
129	"int $0x40"	149	"int $0x40"
130	::"a"(68),"b"(14),"c"(event));	150	::"a"(68),"b"(14),"c"(event));
131	}	151	}
132		152
133	int fplay_vaapi_init(void);	153	int fplay_vaapi_init(void);
134	int init_fontlib();	154	int init_fontlib();
135	char *get_moviefile();	155	char *get_moviefile();
136		156
137	struct>	157	struct>
138		158
139	struct>	159	struct>
140	#define>	160	#define>
141	#define>	161	#define>
142	#define>	162	#define>
143	#define>	163	#define>
144	#define>	164	#define>
145	#define>	165	#define>

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/fplay.h – Rev 6106 → 6117