1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
|
/*#include <xine.h>*/
#include <stdlib.h>
#include <stdio.h>
#include <xine/video_out.h>
#include <xine/xine_internal.h>
#include <xine/xineutils.h>
#include <xine/configfile.h>
typedef struct null_driver_s null_driver_t;
struct null_driver_s {
vo_driver_t vo_driver;
uint32_t m_capabilities;
int m_show_video;
int m_video_fullscreen;
int m_is_scaling;
};
typedef struct opie_frame_s opie_frame_t;
struct opie_frame_s {
vo_frame_t frame;
char* name;
int version;
int m_width;
int m_height;
int m_ratio_code;
int format;
int flags;
int user_ratio;
int ideal_width;
int ideal_height;
int output_width, output_height;
uint8_t *chunk[3];
uint8_t *rgb_dst;
int yuv_stride;
int stripe_height, stripe_inc;
int bytes_per_line;
uint8_t *data;
null_driver_t *output;
};
static uint32_t null_get_capabilities(vo_driver_t *self ){
null_driver_t* this = (null_driver_t*)self;
printf("capabilities\n");
return this->m_capabilities;
}
/* take care of the frame*/
static void null_frame_dispose( vo_frame_t* vo_img){
opie_frame_t* frame = (opie_frame_t*)vo_img;
printf("frame_dispose\n");
free (frame);
}
static void null_frame_field( vo_frame_t* frame, int inti ){
printf("frame_field\n");
/* not needed */
}
/* end take care of frames*/
static vo_frame_t* null_alloc_frame( vo_driver_t* self ){
null_driver_t* this = (null_driver_t*)self;
opie_frame_t* frame = (opie_frame_t*)malloc ( sizeof(opie_frame_t) );
memset( frame, 0, sizeof( opie_frame_t) );
printf("alloc_frame\n");
frame->name = "opie\0";
frame->version = 1;
frame->output = this;
/* initialize the frame*/
frame->frame.driver = self;
/*frame.frame.free = null_frame_free;*/
frame->frame.copy = NULL;
frame->frame.field = null_frame_field;
frame->frame.dispose = null_frame_dispose;
return (vo_frame_t*) frame;
}
static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img,
uint32_t width, uint32_t height,
int ratio_code, int format, int flags ){
null_driver_t* this = (null_driver_t*) self;
opie_frame_t* frame = (opie_frame_t*)img;
/* not needed now */
printf("update_frame_format\n");
printf("al crash aye?\n");
if(frame->chunk[0] ){
free( frame->chunk[0] );
frame->chunk[0] = NULL;
}
if(frame->chunk[1] ){
free ( frame->chunk[1] );
frame->chunk[1] = NULL;
}
if(frame->chunk[2] ){
free ( frame->chunk[2] );
frame->chunk[2] = NULL;
}
if( format == IMGFMT_YV12 ) {
int image_size = width * height; /* cast ouch*/
frame->frame.base[0] = xine_xmalloc_aligned(16, image_size,
(void **)&frame->chunk[0] );
frame->frame.base[1] = xine_xmalloc_aligned(16, image_size,
(void **)&frame->chunk[1] );
frame->frame.base[2] = xine_xmalloc_aligned(16, image_size,
(void **)&frame->chunk[2] );
}else{
int image_size = width * height; /* cast ouch*/
frame->frame.base[0] = xine_xmalloc_aligned(16, image_size,
(void **)&frame->chunk[0] );
frame->chunk[1] = NULL;
frame->chunk[2] = NULL;
}
}
static void null_display_frame( vo_driver_t* self, vo_frame_t *frame ){
printf("display frame\n");
}
static void null_overlay_blend( vo_driver_t* self, vo_frame_t* frame,
vo_overlay_t* overlay ){
/* sure */
}
static int null_get_property( vo_driver_t* self,
int property ){
printf("property get]n");
return 0;
}
static int null_set_property( vo_driver_t* self,
int property,
int value ){
printf("set property\n");
return value;
}
static void null_get_property_min_max( vo_driver_t* self,
int property, int *min,
int *max ){
printf("min max\n");
*max = 0;
*min = 0;
}
static int null_gui_data_exchange( vo_driver_t* self,
int data_type,
void *data ){
return 0;
}
static void null_exit( vo_driver_t* self ){
null_driver_t* this = (null_driver_t*)self;
free ( this );
}
static int null_redraw_needed( vo_driver_t* self ){
return 0;
}
vo_driver_t* init_video_out_plugin( config_values_t* conf,
void* video ){
null_driver_t *vo;
vo = (null_driver_t*)malloc( sizeof(null_driver_t ) );
vo->m_show_video = 0; // false
vo->m_video_fullscreen = 0;
vo->m_is_scaling = 0;
/* memset? */
/* install callback handlers*/
vo->vo_driver.get_capabilities = null_get_capabilities;
vo->vo_driver.alloc_frame = null_alloc_frame;
vo->vo_driver.update_frame_format = null_update_frame_format;
vo->vo_driver.display_frame = null_display_frame;
vo->vo_driver.overlay_blend = null_overlay_blend;
vo->vo_driver.get_property = null_get_property;
vo->vo_driver.set_property = null_set_property;
vo->vo_driver.get_property_min_max = null_get_property_min_max;
vo->vo_driver.gui_data_exchange = null_gui_data_exchange;
vo->vo_driver.exit = null_exit;
vo->vo_driver.redraw_needed = null_redraw_needed;
/* capabilities */
vo->m_capabilities = /*VO_CAP_COPIES_IMAGE |*/ VO_CAP_YV12 | VO_CAP_BRIGHTNESS;
printf("done initialisation\n");
return (vo_driver_t*) vo;
}
static vo_info_t vo_info_null = {
5,
"null plugin",
NULL,
VISUAL_TYPE_FB,
5
};
vo_info_t *get_video_out_plugin_info(){
vo_info_null.description = _("xine video output plugin using null device");
return &vo_info_null;
}
/* this is special for this device */
/**
* We know that we will be controled by the XINE LIB++
*/
/**
*
*/
int null_is_showing_video( vo_driver_t* self ){
null_driver_t* this = (null_driver_t*)self;
return this->m_show_video;
}
void null_set_show_video( vo_driver_t* self, int show ) {
((null_driver_t*)self)->m_show_video = show;
}
int null_is_fullscreen( vo_driver_t* self ){
return ((null_driver_t*)self)->m_video_fullscreen;
}
void null_set_fullscreen( vo_driver_t* self, int screen ){
((null_driver_t*)self)->m_video_fullscreen = screen;
}
int null_is_scaling( vo_driver_t* self ){
return ((null_driver_t*)self)->m_is_scaling;
}
void null_set_scaling( vo_driver_t* self, int scale ){
((null_driver_t*)self)->m_is_scaling = scale;
}
void null_set_gui_width( vo_driver_t* self, int width ){
}
void null_set_gui_height( vo_driver_t* self, int height ){
}
|
