Mercurial > mplayer.hg
annotate libmpcodecs/vf_bmovl.c @ 9593:e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
Syntax is we decided, so you can give the nomes or not with both
vop and vf. vf take precedence over vop.
author | albeu |
---|---|
date | Sat, 15 Mar 2003 18:01:02 +0000 |
parents | 67d28a3f918a |
children | 298e261aecd7 |
rev | line source |
---|---|
7855 | 1 /* vf_bmovl.c v0.9.1 - BitMap OVerLay videofilter for MPlayer |
2 * | |
3 * (C) 2002 Per Wigren <wigren@home.se> | |
4 * Licenced under the GNU General Public License | |
5 * | |
6 * Use MPlayer as a framebuffer to read bitmaps and commands from a FIFO | |
7 * and display them in the window. | |
8 * | |
7895 | 9 * Commands are: |
7855 | 10 * |
7895 | 11 * RGBA32 width height xpos ypos alpha clear |
12 * * Followed by width*height*4 bytes of raw RGBA32 data. | |
13 * ABGR32 width height xpos ypos alpha clear | |
14 * * Followed by width*height*4 bytes of raw ABGR32 data. | |
15 * RGB24 width height xpos ypos alpha clear | |
16 * * Followed by width*height*3 bytes of raw RGB32 data. | |
17 * BGR24 width height xpos ypos alpha clear | |
18 * * Followed by width*height*3 bytes of raw BGR32 data. | |
7855 | 19 * |
7895 | 20 * ALPHA width height xpos ypos alpha |
21 * * Change alpha for area | |
22 * CLEAR width height xpos ypos | |
23 * * Clear area | |
24 * OPAQUE | |
25 * * Disable all alpha transparency! | |
26 * Send "ALPHA 0 0 0 0 0" to enable again! | |
27 * HIDE | |
28 * * Hide bitmap | |
29 * SHOW | |
30 * * Show bitmap | |
7855 | 31 * |
32 * Arguments are: | |
33 * width, height Size of image/area | |
34 * xpos, ypos Start blitting at X/Y position | |
35 * alpha Set alpha difference. 0 means same as original. | |
36 * 255 makes everything opaque | |
37 * -255 makes everything transparent | |
38 * If you set this to -255 you can then send a sequence of | |
39 * ALPHA-commands to set the area to -225, -200, -175 etc | |
40 * for a nice fade-in-effect! ;) | |
41 * clear Clear the framebuffer before blitting. 1 means clear. | |
42 * If 0, the image will just be blitted on top of the old | |
43 * one, so you don't need to send 1,8MB of RGBA32 data | |
44 * everytime a small part of the screen is updated. | |
45 * | |
46 * Arguments for the filter are hidden:opaque:fifo | |
47 * For example 1:0:/tmp/myfifo.fifo will start the filter hidden, transparent | |
48 * and use /tmp/myfifo.fifo as the fifo. | |
49 * | |
50 * If you find bugs, please send me patches! ;) | |
51 * | |
52 * This filter was developed for use in Freevo (http://freevo.sf.net), but | |
53 * anyone is free to use it! ;) | |
54 * | |
55 */ | |
56 | |
57 #include <stdio.h> | |
58 #include <stdlib.h> | |
59 #include <string.h> | |
60 #include <unistd.h> | |
61 #include <errno.h> | |
62 #include <sys/stat.h> | |
63 #include <sys/types.h> | |
7858 | 64 #include <sys/time.h> |
7855 | 65 #include <fcntl.h> |
66 #include "mp_image.h" | |
67 #include "vf.h" | |
68 #include "img_format.h" | |
69 | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
70 #include "../mp_msg.h" |
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
71 |
7855 | 72 #include "../libvo/fastmemcpy.h" |
73 | |
74 #define IS_RAWIMG 0x100 | |
75 #define IS_IMG 0x200 | |
76 | |
77 #define NONE 0x000 | |
78 #define IMG_RGBA32 0x101 | |
79 #define IMG_ABGR32 0x102 | |
80 #define IMG_RGB24 0x103 | |
81 #define IMG_BGR24 0x104 | |
82 #define IMG_PNG 0x201 | |
83 #define CMD_CLEAR 0x001 | |
84 #define CMD_ALPHA 0x002 | |
85 | |
86 #define TRUE 1 | |
87 #define FALSE 0 | |
88 | |
89 #define MAX(a,b) ((a) > (b) ? (a) : (b)) | |
90 #define MIN(a,b) ((a) < (b) ? (a) : (b)) | |
91 #define INRANGE(a,b,c) ( ((a) < (b)) ? (b) : ( ((a) > (c)) ? (c) : (a) ) ) | |
92 | |
9131
67d28a3f918a
The code for converting RGB to YUV in bmovl is slow because it uses
arpi
parents:
9110
diff
changeset
|
93 #define rgb2y(R,G,B) ( (( 263*R + 516*G + 100*B) >> 10) + 16 ) |
67d28a3f918a
The code for converting RGB to YUV in bmovl is slow because it uses
arpi
parents:
9110
diff
changeset
|
94 #define rgb2u(R,G,B) ( ((-152*R - 298*G + 450*B) >> 10) + 128 ) |
67d28a3f918a
The code for converting RGB to YUV in bmovl is slow because it uses
arpi
parents:
9110
diff
changeset
|
95 #define rgb2v(R,G,B) ( (( 450*R - 376*G - 73*B) >> 10) + 128 ) |
7855 | 96 |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
97 #define DBG(a) (mp_msg(MSGT_VFILTER, MSGL_DBG2, "DEBUG: %d\n", a)) |
7855 | 98 |
99 struct vf_priv_s { | |
100 int w, h, x1, y1, x2, y2; | |
101 struct { | |
102 unsigned char *y, *u, *v, *a, *oa; | |
103 } bitmap; | |
104 int stream_fd; | |
105 fd_set stream_fdset; | |
106 int opaque, hidden; | |
107 }; | |
108 | |
109 static int | |
110 query_format(struct vf_instance_s* vf, unsigned int fmt){ | |
111 if(fmt==IMGFMT_YV12) return VFCAP_CSP_SUPPORTED; | |
112 return 0; | |
113 } | |
114 | |
115 | |
116 static int | |
117 config(struct vf_instance_s* vf, | |
118 int width, int height, int d_width, int d_height, | |
119 unsigned int flags, unsigned int outfmt) | |
120 { | |
121 vf->priv->bitmap.y = malloc( width*height ); | |
122 vf->priv->bitmap.u = malloc( width*height/4 ); | |
123 vf->priv->bitmap.v = malloc( width*height/4 ); | |
124 vf->priv->bitmap.a = malloc( width*height ); | |
125 vf->priv->bitmap.oa = malloc( width*height ); | |
126 if(!( vf->priv->bitmap.y && | |
127 vf->priv->bitmap.u && | |
128 vf->priv->bitmap.v && | |
129 vf->priv->bitmap.a && | |
130 vf->priv->bitmap.oa )) { | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
131 mp_msg(MSGT_VFILTER, MSGL_ERR, "vf_bmovl: Could not allocate memory for bitmap buffer: %s\n", strerror(errno) ); |
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
132 return FALSE; |
7855 | 133 } |
134 | |
135 // Set default to black... | |
136 memset( vf->priv->bitmap.u, 128, width*height/4 ); | |
137 memset( vf->priv->bitmap.v, 128, width*height/4 ); | |
138 | |
139 vf->priv->w = vf->priv->x1 = width; | |
140 vf->priv->h = vf->priv->y1 = height; | |
141 vf->priv->y2 = vf->priv->x2 = 0; | |
142 | |
143 return vf_next_config(vf, width, height, d_width, d_height, flags, outfmt); | |
144 } | |
145 | |
146 static void | |
147 uninit(struct vf_instance_s *vf) | |
148 { | |
149 if(vf->priv) { | |
150 free(vf->priv->bitmap.y); | |
151 free(vf->priv->bitmap.u); | |
152 free(vf->priv->bitmap.v); | |
153 free(vf->priv->bitmap.a); | |
154 free(vf->priv->bitmap.oa); | |
155 free(vf->priv); | |
156 } | |
157 } | |
158 | |
159 static int | |
160 _read_cmd(int fd, char *cmd, char *args) { | |
161 int done=FALSE, pos=0; | |
162 char tmp; | |
163 | |
164 while(!done) { | |
165 if(! read( fd, &tmp, 1 ) ) return FALSE; | |
166 if( (tmp>='A' && tmp<='Z') || (tmp>='0' && tmp<='9') ) | |
167 cmd[pos]=tmp; | |
168 else if(tmp == ' ') { | |
169 cmd[pos]='\0'; | |
170 done=TRUE; | |
171 } | |
172 else if(tmp == '\n') { | |
173 cmd[pos]='\0'; | |
174 args[0]='\0'; | |
175 return TRUE; | |
176 } | |
177 if(pos++>20) { | |
178 cmd[0]='\0'; | |
179 return TRUE; | |
180 } | |
181 } | |
182 done=FALSE; pos=0; | |
183 while(!done) { | |
184 if(! read( fd, &tmp, 1 ) ) return FALSE; | |
185 if( (tmp >= ' ') && (pos<100) ) args[pos]=tmp; | |
186 else { | |
187 args[pos]='\0'; | |
188 done=TRUE; | |
189 } | |
190 pos++; | |
191 } | |
192 return TRUE; | |
193 } | |
194 | |
195 | |
196 static int | |
197 put_image(struct vf_instance_s* vf, mp_image_t* mpi){ | |
198 int buf_x=0, buf_y=0, buf_pos=0; | |
199 int xpos=0, ypos=0, pos=0; | |
200 unsigned char red=0, green=0, blue=0; | |
201 int alpha; | |
202 mp_image_t* dmpi; | |
203 | |
204 dmpi = vf_get_image(vf->next, mpi->imgfmt, MP_IMGTYPE_TEMP, | |
205 MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_PREFER_ALIGNED_STRIDE, | |
206 mpi->w, mpi->h); | |
207 | |
208 memcpy( dmpi->planes[0], mpi->planes[0], mpi->stride[0] * mpi->height); | |
209 memcpy( dmpi->planes[1], mpi->planes[1], mpi->stride[1] * mpi->chroma_height); | |
210 memcpy( dmpi->planes[2], mpi->planes[2], mpi->stride[2] * mpi->chroma_height); | |
211 | |
212 if(vf->priv->stream_fd >= 0) { | |
213 struct timeval tv; | |
214 | |
215 FD_SET( vf->priv->stream_fd, &vf->priv->stream_fdset ); | |
216 tv.tv_sec=0; tv.tv_usec=0; | |
217 | |
218 if( select( vf->priv->stream_fd+1, &vf->priv->stream_fdset, NULL, NULL, &tv ) > 0) { | |
219 // We've got new data from the FIFO | |
220 | |
221 char cmd[20], args[100]; | |
222 int imgw,imgh,imgx,imgy,clear,imgalpha,pxsz=1,command; | |
223 unsigned char *buffer = NULL; | |
224 | |
225 if(! _read_cmd( vf->priv->stream_fd, cmd, args) ) { | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
226 mp_msg(MSGT_VFILTER, MSGL_ERR, "\nvf_bmovl: Error reading commands: %s\n\n", strerror(errno)); |
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
227 return FALSE; |
7855 | 228 } |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
229 mp_msg(MSGT_VFILTER, MSGL_DBG2, "\nDEBUG: Got: %s+%s\n", cmd, args); |
7855 | 230 |
231 command=NONE; | |
232 if ( strncmp(cmd,"RGBA32",6)==0 ) { pxsz=4; command = IMG_RGBA32; } | |
233 else if( strncmp(cmd,"ABGR32",6)==0 ) { pxsz=4; command = IMG_ABGR32; } | |
234 else if( strncmp(cmd,"RGB24" ,5)==0 ) { pxsz=3; command = IMG_RGB24; } | |
235 else if( strncmp(cmd,"BGR24" ,5)==0 ) { pxsz=3; command = IMG_BGR24; } | |
236 else if( strncmp(cmd,"CLEAR" ,5)==0 ) { pxsz=1; command = CMD_CLEAR; } | |
237 else if( strncmp(cmd,"ALPHA" ,5)==0 ) { pxsz=1; command = CMD_ALPHA; } | |
238 else if( strncmp(cmd,"OPAQUE",6)==0 ) vf->priv->opaque=TRUE; | |
239 else if( strncmp(cmd,"SHOW", 4)==0 ) vf->priv->hidden=FALSE; | |
240 else if( strncmp(cmd,"HIDE", 4)==0 ) vf->priv->hidden=TRUE; | |
241 else if( strncmp(cmd,"FLUSH" ,5)==0 ) return vf_next_put_image(vf, dmpi); | |
242 else { | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
243 mp_msg(MSGT_VFILTER, MSGL_WARN, "\nvf_bmovl: Unknown command: '%s'. Ignoring.\n", cmd); |
7855 | 244 return vf_next_put_image(vf, dmpi); |
245 } | |
246 | |
247 if(command == CMD_ALPHA) { | |
248 sscanf( args, "%d %d %d %d %d", &imgw, &imgh, &imgx, &imgy, &imgalpha); | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
249 mp_msg(MSGT_VFILTER, MSGL_DBG2, "\nDEBUG: ALPHA: %d %d %d %d %d\n\n", |
7855 | 250 imgw, imgh, imgx, imgy, imgalpha); |
251 if(imgw==0 && imgh==0) vf->priv->opaque=FALSE; | |
252 } | |
253 | |
254 if(command & IS_RAWIMG) { | |
255 sscanf( args, "%d %d %d %d %d %d", | |
256 &imgw, &imgh, &imgx, &imgy, &imgalpha, &clear); | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
257 mp_msg(MSGT_VFILTER, MSGL_DBG2, "\nDEBUG: RAWIMG: %d %d %d %d %d %d\n\n", |
7855 | 258 imgw, imgh, imgx, imgy, imgalpha, clear); |
259 | |
260 buffer = malloc(imgw*imgh*pxsz); | |
261 if(!buffer) { | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
262 mp_msg(MSGT_VFILTER, MSGL_WARN, "\nvf_bmovl: Couldn't allocate temporary buffer! Skipping...\n\n"); |
7855 | 263 return vf_next_put_image(vf, dmpi); |
264 } | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
265 mp_msg(MSGT_VFILTER, MSGL_DBG2, "Got %d bytes...\n", read( vf->priv->stream_fd, buffer, (imgw*imgh*pxsz) ) ); |
7855 | 266 |
267 if(clear) { | |
268 memset( vf->priv->bitmap.y, 0, vf->priv->w*vf->priv->h ); | |
269 memset( vf->priv->bitmap.u, 128, vf->priv->w*vf->priv->h/4 ); | |
270 memset( vf->priv->bitmap.v, 128, vf->priv->w*vf->priv->h/4 ); | |
271 memset( vf->priv->bitmap.a, 0, vf->priv->w*vf->priv->h ); | |
272 memset( vf->priv->bitmap.oa, 0, vf->priv->w*vf->priv->h ); | |
273 vf->priv->x1 = dmpi->width; | |
274 vf->priv->y1 = dmpi->height; | |
275 vf->priv->x2 = vf->priv->y2 = 0; | |
276 } | |
277 // Define how much of our bitmap that contains graphics! | |
278 vf->priv->x1 = MAX( 0, MIN(vf->priv->x1, imgx) ); | |
279 vf->priv->y1 = MAX( 0, MIN(vf->priv->y1, imgy) ); | |
280 vf->priv->x2 = MIN( vf->priv->w, MAX(vf->priv->x2, ( imgx + imgw)) ); | |
281 vf->priv->y2 = MIN( vf->priv->h, MAX(vf->priv->y2, ( imgy + imgh)) ); | |
282 } | |
283 | |
284 if( command == CMD_CLEAR ) { | |
285 sscanf( args, "%d %d %d %d", &imgw, &imgh, &imgx, &imgy); | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
286 mp_msg(MSGT_VFILTER, MSGL_DBG2, "\nDEBUG: CLEAR: %d %d %d %d\n\n", imgw, imgh, imgx, imgy); |
7855 | 287 |
288 for( ypos=imgy ; (ypos < (imgy+imgh)) && (ypos < vf->priv->y2) ; ypos++ ) { | |
289 memset( vf->priv->bitmap.y + (ypos*vf->priv->w) + imgx, 0, imgw ); | |
290 memset( vf->priv->bitmap.a + (ypos*vf->priv->w) + imgx, 0, imgw ); | |
291 memset( vf->priv->bitmap.oa + (ypos*vf->priv->w) + imgx, 0, imgw ); | |
292 if(ypos%2) { | |
293 memset( vf->priv->bitmap.u + ((ypos/2)*dmpi->stride[1]) + (imgx/2), 128, imgw/2 ); | |
294 memset( vf->priv->bitmap.v + ((ypos/2)*dmpi->stride[2]) + (imgx/2), 128, imgw/2 ); | |
295 } | |
296 } // Recalculate area that contains graphics | |
297 if( (imgx <= vf->priv->x1) && ( (imgw+imgx) >= vf->priv->x2) ) { | |
298 if( (imgy <= vf->priv->y1) && ( (imgy+imgh) >= vf->priv->y1) ) | |
299 vf->priv->y1 = imgy+imgh; | |
300 if( (imgy <= vf->priv->y2) && ( (imgy+imgh) >= vf->priv->y2) ) | |
301 vf->priv->y2 = imgy; | |
302 } | |
303 if( (imgy <= vf->priv->y1) && ( (imgy+imgh) >= vf->priv->y2) ) { | |
304 if( (imgx <= vf->priv->x1) && ( (imgx+imgw) >= vf->priv->x1) ) | |
305 vf->priv->x1 = imgx+imgw; | |
306 if( (imgx <= vf->priv->x2) && ( (imgx+imgw) >= vf->priv->x2) ) | |
307 vf->priv->x2 = imgx; | |
308 } | |
309 return vf_next_put_image(vf, dmpi); | |
310 } | |
311 | |
312 for( buf_y=0 ; (buf_y < imgh) && (buf_y < (vf->priv->h-imgy)) ; buf_y++ ) { | |
313 for( buf_x=0 ; (buf_x < (imgw*pxsz)) && (buf_x < ((vf->priv->w+imgx)*pxsz)) ; buf_x += pxsz ) { | |
314 if(command & IS_RAWIMG) buf_pos = (buf_y * imgw * pxsz) + buf_x; | |
315 pos = ((buf_y+imgy) * vf->priv->w) + ((buf_x/pxsz)+imgx); | |
316 | |
317 switch(command) { | |
318 case IMG_RGBA32: | |
319 red = buffer[buf_pos+0]; | |
320 green = buffer[buf_pos+1]; | |
321 blue = buffer[buf_pos+2]; | |
322 alpha = buffer[buf_pos+3]; | |
323 break; | |
324 case IMG_ABGR32: | |
325 alpha = buffer[buf_pos+0]; | |
326 blue = buffer[buf_pos+1]; | |
327 green = buffer[buf_pos+2]; | |
328 red = buffer[buf_pos+3]; | |
329 break; | |
330 case IMG_RGB24: | |
331 red = buffer[buf_pos+0]; | |
332 green = buffer[buf_pos+1]; | |
333 blue = buffer[buf_pos+2]; | |
334 alpha = 0xFF; | |
335 break; | |
336 case IMG_BGR24: | |
337 blue = buffer[buf_pos+0]; | |
338 green = buffer[buf_pos+1]; | |
339 red = buffer[buf_pos+2]; | |
340 alpha = 0xFF; | |
341 break; | |
342 case CMD_ALPHA: | |
343 vf->priv->bitmap.a[pos] = INRANGE((vf->priv->bitmap.oa[pos]+imgalpha),0,255); | |
344 break; | |
345 default: | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
346 mp_msg(MSGT_VFILTER, MSGL_ERR, "vf_bmovl: Internal error!\n"); |
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
347 return FALSE; |
7855 | 348 } |
349 if( command & IS_RAWIMG ) { | |
350 vf->priv->bitmap.y[pos] = rgb2y(red,green,blue); | |
351 vf->priv->bitmap.oa[pos] = alpha; | |
352 vf->priv->bitmap.a[pos] = INRANGE((alpha+imgalpha),0,255); | |
353 if((buf_y%2) && ((buf_x/pxsz)%2)) { | |
354 pos = ( ((buf_y+imgy)/2) * dmpi->stride[1] ) + (((buf_x/pxsz)+imgx)/2); | |
355 vf->priv->bitmap.u[pos] = rgb2u(red,green,blue); | |
356 vf->priv->bitmap.v[pos] = rgb2v(red,green,blue); | |
357 } | |
358 } | |
359 } // for buf_x | |
360 } // for buf_y | |
361 free (buffer); | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
362 } else if(errno) mp_msg(MSGT_VFILTER, MSGL_WARN, "\nvf_bmovl: Error %d in fifo: %s\n\n", errno, strerror(errno)); |
7855 | 363 } |
364 | |
365 if(vf->priv->hidden) return vf_next_put_image(vf, dmpi); | |
366 | |
367 if(vf->priv->opaque) { // Just copy buffer memory to screen | |
368 for( ypos=vf->priv->y1 ; ypos < vf->priv->y2 ; ypos++ ) { | |
369 memcpy( dmpi->planes[0] + (ypos*dmpi->stride[0]) + vf->priv->x1, | |
370 vf->priv->bitmap.y + (ypos*vf->priv->w) + vf->priv->x1, | |
371 vf->priv->x2 - vf->priv->x1 ); | |
372 if(ypos%2) { | |
373 memcpy( dmpi->planes[1] + ((ypos/2)*dmpi->stride[1]) + (vf->priv->x1/2), | |
374 vf->priv->bitmap.u + (((ypos/2)*(vf->priv->w)/2)) + (vf->priv->x1/2), | |
375 (vf->priv->x2 - vf->priv->x1)/2 ); | |
376 memcpy( dmpi->planes[2] + ((ypos/2)*dmpi->stride[2]) + (vf->priv->x1/2), | |
377 vf->priv->bitmap.v + (((ypos/2)*(vf->priv->w)/2)) + (vf->priv->x1/2), | |
378 (vf->priv->x2 - vf->priv->x1)/2 ); | |
379 } | |
380 } | |
381 } else { // Blit the bitmap to the videoscreen, pixel for pixel | |
382 for( ypos=vf->priv->y1 ; ypos < vf->priv->y2 ; ypos++ ) { | |
383 for ( xpos=vf->priv->x1 ; xpos < vf->priv->x2 ; xpos++ ) { | |
384 pos = (ypos * dmpi->stride[0]) + xpos; | |
385 | |
386 alpha = vf->priv->bitmap.a[pos]; | |
387 | |
388 if (alpha == 0) continue; // Completly transparent pixel | |
389 | |
390 if (alpha == 255) { // Opaque pixel | |
391 dmpi->planes[0][pos] = vf->priv->bitmap.y[pos]; | |
392 if ((ypos%2) && (xpos%2)) { | |
393 pos = ( (ypos/2) * dmpi->stride[1] ) + (xpos/2); | |
394 dmpi->planes[1][pos] = vf->priv->bitmap.u[pos]; | |
395 dmpi->planes[2][pos] = vf->priv->bitmap.v[pos]; | |
396 } | |
397 } else { // Alphablended pixel | |
9110
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
398 dmpi->planes[0][pos] = |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
399 ((255 - alpha) * (int)dmpi->planes[0][pos] + |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
400 alpha * (int)vf->priv->bitmap.y[pos]) >> 8; |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
401 |
7855 | 402 if ((ypos%2) && (xpos%2)) { |
403 pos = ( (ypos/2) * dmpi->stride[1] ) + (xpos/2); | |
9110
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
404 |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
405 dmpi->planes[1][pos] = |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
406 ((255 - alpha) * (int)dmpi->planes[1][pos] + |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
407 alpha * (int)vf->priv->bitmap.u[pos]) >> 8; |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
408 |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
409 dmpi->planes[2][pos] = |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
410 ((255 - alpha) * (int)dmpi->planes[2][pos] + |
7924a60d833b
This is a simple patch to change the alpha blending code in bmovl to use
arpi
parents:
8878
diff
changeset
|
411 alpha * (int)vf->priv->bitmap.v[pos]) >> 8; |
7855 | 412 } |
413 } | |
414 } // for xpos | |
415 } // for ypos | |
416 } // if !opaque | |
417 return vf_next_put_image(vf, dmpi); | |
418 } // put_image | |
419 | |
420 static int | |
421 vf_open(vf_instance_t* vf, char* args) | |
422 { | |
423 char filename[1000]; | |
424 | |
425 vf->config = config; | |
426 vf->put_image = put_image; | |
427 vf->query_format = query_format; | |
428 vf->uninit = uninit; | |
429 | |
430 vf->priv = malloc(sizeof(struct vf_priv_s)); | |
431 | |
432 if( sscanf(args, "%d:%d:%s", &vf->priv->hidden, &vf->priv->opaque, filename) < 3 ) { | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
433 mp_msg(MSGT_VFILTER, MSGL_ERR, "vf_bmovl: Bad arguments!\n"); |
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
434 mp_msg(MSGT_VFILTER, MSGL_ERR, "vf_bmovl: Arguments are 'bool hidden:bool opaque:string fifo'\n"); |
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
435 return FALSE; |
7855 | 436 } |
437 | |
438 vf->priv->stream_fd = open(filename, O_RDWR); | |
439 if(vf->priv->stream_fd >= 0) { | |
440 FD_ZERO( &vf->priv->stream_fdset ); | |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
441 mp_msg(MSGT_VFILTER, MSGL_INFO, "vf_bmovl: Opened fifo %s as FD %d\n", filename, vf->priv->stream_fd); |
7855 | 442 } else { |
8878
12e69a0d5a67
may not be perfect but it's certainly a start. feel free to change
rfelker
parents:
7895
diff
changeset
|
443 mp_msg(MSGT_VFILTER, MSGL_WARN, "vf_bmovl: Error! Couldn't open FIFO %s: %s\n", filename, strerror(errno)); |
7855 | 444 vf->priv->stream_fd = -1; |
445 } | |
446 | |
447 return TRUE; | |
448 } | |
449 | |
450 vf_info_t vf_info_bmovl = { | |
451 "Read bitmaps from a FIFO and display them in window", | |
452 "bmovl", | |
453 "Per Wigren", | |
454 "", | |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9131
diff
changeset
|
455 vf_open, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9131
diff
changeset
|
456 NULL |
7855 | 457 }; |