Diffstat (limited to 'noncore/multimedia/opieplayer2/nullvideo.c') (more/less context) (ignore whitespace changes)
-rw-r--r-- | noncore/multimedia/opieplayer2/nullvideo.c | 359 |
1 files changed, 226 insertions, 133 deletions
diff --git a/noncore/multimedia/opieplayer2/nullvideo.c b/noncore/multimedia/opieplayer2/nullvideo.c index 378bbd4..6769a37 100644 --- a/noncore/multimedia/opieplayer2/nullvideo.c +++ b/noncore/multimedia/opieplayer2/nullvideo.c | |||
@@ -3,8 +3,9 @@ | |||
3 | 3 | ||
4 | Copyright (c) 2002 Max Reiss <harlekin@handhelds.org> | 4 | Copyright (c) 2002 Max Reiss <harlekin@handhelds.org> |
5 | Copyright (c) 2002 LJP <> | 5 | Copyright (c) 2002 LJP <> |
6 | Copyright (c) 2002 Holger Freyther <zecke@handhelds.org> | 6 | Copyright (c) 2002 Holger Freyther <zecke@handhelds.org> |
7 | Copyright (c) 2002-2003 Miguel Freitas of xine | ||
7 | =. | 8 | =. |
8 | .=l. | 9 | .=l. |
9 | .>+-= | 10 | .>+-= |
10 | _;:, .> :=|. This program is free software; you can | 11 | _;:, .> :=|. This program is free software; you can |
@@ -112,9 +113,9 @@ static uint32_t null_get_capabilities( vo_driver_t *self ){ | |||
112 | null_driver_t* this = (null_driver_t*)self; | 113 | null_driver_t* this = (null_driver_t*)self; |
113 | return this->m_capabilities; | 114 | return this->m_capabilities; |
114 | } | 115 | } |
115 | 116 | ||
116 | static void null_frame_copy (vo_frame_t *vo_img, uint8_t **src) { | 117 | static void null_frame_proc_slice (vo_frame_t *vo_img, uint8_t **src) { |
117 | opie_frame_t *frame = (opie_frame_t *) vo_img ; | 118 | opie_frame_t *frame = (opie_frame_t *) vo_img ; |
118 | 119 | ||
119 | vo_img->proc_called = 1; | 120 | vo_img->proc_called = 1; |
120 | 121 | ||
@@ -174,20 +175,19 @@ static vo_frame_t* null_alloc_frame( vo_driver_t* self ){ | |||
174 | #ifdef LOG | 175 | #ifdef LOG |
175 | fprintf (stderr, "nullvideo: alloc_frame\n"); | 176 | fprintf (stderr, "nullvideo: alloc_frame\n"); |
176 | #endif | 177 | #endif |
177 | 178 | ||
178 | frame = (opie_frame_t*)malloc ( sizeof(opie_frame_t) ); | 179 | frame = (opie_frame_t*)xine_xmalloc ( sizeof(opie_frame_t) ); |
179 | 180 | ||
180 | memset( frame, 0, sizeof( opie_frame_t) ); | ||
181 | memcpy (&frame->sc, &this->sc, sizeof(vo_scale_t)); | 181 | memcpy (&frame->sc, &this->sc, sizeof(vo_scale_t)); |
182 | 182 | ||
183 | pthread_mutex_init (&frame->frame.mutex, NULL); | 183 | pthread_mutex_init (&frame->frame.mutex, NULL); |
184 | 184 | ||
185 | frame->output = this; | 185 | frame->output = this; |
186 | 186 | ||
187 | /* initialize the frame*/ | 187 | /* initialize the frame*/ |
188 | frame->frame.driver = self; | 188 | frame->frame.driver = self; |
189 | frame->frame.proc_slice = null_frame_copy; | 189 | frame->frame.proc_slice = null_frame_proc_slice; |
190 | frame->frame.field = null_frame_field; | 190 | frame->frame.field = null_frame_field; |
191 | frame->frame.dispose = null_frame_dispose; | 191 | frame->frame.dispose = null_frame_dispose; |
192 | 192 | ||
193 | /* | 193 | /* |
@@ -197,53 +197,36 @@ static vo_frame_t* null_alloc_frame( vo_driver_t* self ){ | |||
197 | 197 | ||
198 | return (vo_frame_t*) frame; | 198 | return (vo_frame_t*) frame; |
199 | } | 199 | } |
200 | 200 | ||
201 | static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img, | ||
202 | uint32_t width, uint32_t height, | ||
203 | double ratio_code, int format, | ||
204 | int flags ){ | ||
205 | null_driver_t* this = (null_driver_t*) self; | ||
206 | opie_frame_t* frame = (opie_frame_t*)img; | ||
207 | /* not needed now */ | ||
208 | 201 | ||
209 | #ifdef LOG | 202 | static void null_frame_compute_ideal_size( null_driver_t *this, |
210 | fprintf (stderr, "nullvideo: update_frame_format\n"); | 203 | opie_frame_t *frame ) { |
211 | #endif | 204 | this = this; |
212 | 205 | ||
213 | flags &= VO_BOTH_FIELDS; | 206 | _x_vo_scale_compute_ideal_size(&frame->sc); |
207 | } | ||
214 | 208 | ||
215 | /* find out if we need to adapt this frame */ | 209 | static void null_frame_compute_rgb_size( null_driver_t *this, |
210 | opie_frame_t *frame ){ | ||
211 | this = this; | ||
216 | 212 | ||
217 | if ((width != frame->sc.delivered_width) | 213 | _x_vo_scale_compute_output_size(&frame->sc); |
218 | || (height != frame->sc.delivered_height) | ||
219 | || (ratio_code != frame->sc.delivered_ratio) | ||
220 | || (flags != frame->flags) | ||
221 | || (format != frame->format) | ||
222 | || (this->sc.user_ratio != frame->sc.user_ratio) | ||
223 | || (this->gui_width != frame->sc.gui_width) | ||
224 | || (this->gui_height != frame->sc.gui_height)) { | ||
225 | 214 | ||
226 | frame->sc.delivered_width = width; | 215 | /* avoid problems in yuv2rgb */ |
227 | frame->sc.delivered_height = height; | 216 | if(frame->sc.output_height < (frame->sc.delivered_height+15) >> 4) |
228 | frame->sc.delivered_ratio = ratio_code; | 217 | frame->sc.output_height = (frame->sc.delivered_height+15) >> 4; |
229 | frame->flags = flags; | ||
230 | frame->format = format; | ||
231 | frame->sc.user_ratio = this->sc.user_ratio; | ||
232 | frame->sc.gui_width = this->gui_width; | ||
233 | frame->sc.gui_height = this->gui_height; | ||
234 | frame->sc.gui_pixel_aspect = 1.0; | ||
235 | 218 | ||
236 | vo_scale_compute_ideal_size ( &frame->sc ); | 219 | if (frame->sc.output_width < 8) |
237 | vo_scale_compute_output_size( &frame->sc ); | 220 | frame->sc.output_width = 8; |
238 | 221 | ||
239 | #ifdef LOG | 222 | /* yuv2rgb_mlib needs an even YUV2 width */ |
240 | fprintf (stderr, "nullvideo: gui %dx%d delivered %dx%d output %dx%d\n", | 223 | if (frame->sc.output_width & 1) |
241 | frame->sc.gui_width, frame->sc.gui_height, | 224 | frame->sc.output_width++; |
242 | frame->sc.delivered_width, frame->sc.delivered_height, | 225 | } |
243 | frame->sc.output_width, frame->sc.output_height); | ||
244 | #endif | ||
245 | 226 | ||
227 | static void null_frame_reallocate( null_driver_t *this, opie_frame_t *frame, | ||
228 | uint32_t width, uint32_t height, int format){ | ||
246 | /* | 229 | /* |
247 | * (re-) allocate | 230 | * (re-) allocate |
248 | */ | 231 | */ |
249 | if( frame->data ) { | 232 | if( frame->data ) { |
@@ -261,9 +244,9 @@ static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img, | |||
261 | } | 244 | } |
262 | free ( frame->data ); | 245 | free ( frame->data ); |
263 | } | 246 | } |
264 | 247 | ||
265 | frame->data = xine_xmalloc (frame->sc.output_width | 248 | frame->data = xine_xmalloc (frame->sc.output_width |
266 | * frame->sc.output_height | 249 | * frame->sc.output_height |
267 | * this->bytes_per_pixel ); | 250 | * this->bytes_per_pixel ); |
268 | 251 | ||
269 | if( format == XINE_IMGFMT_YV12 ) { | 252 | if( format == XINE_IMGFMT_YV12 ) { |
@@ -282,65 +265,118 @@ static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img, | |||
282 | frame->chunk[1] = NULL; | 265 | frame->chunk[1] = NULL; |
283 | frame->chunk[2] = NULL; | 266 | frame->chunk[2] = NULL; |
284 | } | 267 | } |
285 | 268 | ||
269 | } | ||
270 | |||
271 | static void null_setup_colorspace_converter(opie_frame_t *frame, int flags ) { | ||
272 | switch (flags) { | ||
273 | case VO_TOP_FIELD: | ||
274 | case VO_BOTTOM_FIELD: | ||
275 | frame->yuv2rgb->configure (frame->yuv2rgb, | ||
276 | frame->sc.delivered_width, | ||
277 | 16, | ||
278 | 2*frame->frame.pitches[0], | ||
279 | 2*frame->frame.pitches[1], | ||
280 | frame->sc.output_width, | ||
281 | frame->stripe_height, | ||
282 | frame->bytes_per_line*2); | ||
283 | frame->yuv_stride = frame->bytes_per_line*2; | ||
284 | break; | ||
285 | case VO_BOTH_FIELDS: | ||
286 | frame->yuv2rgb->configure (frame->yuv2rgb, | ||
287 | frame->sc.delivered_width, | ||
288 | 16, | ||
289 | frame->frame.pitches[0], | ||
290 | frame->frame.pitches[1], | ||
291 | frame->sc.output_width, | ||
292 | frame->stripe_height, | ||
293 | frame->bytes_per_line); | ||
294 | frame->yuv_stride = frame->bytes_per_line; | ||
295 | break; | ||
296 | } | ||
297 | #ifdef LOG | ||
298 | fprintf (stderr, "nullvideo: colorspace converter configured.\n"); | ||
299 | #endif | ||
300 | } | ||
301 | |||
302 | static void null_update_frame_format( vo_driver_t* self, vo_frame_t* img, | ||
303 | uint32_t width, uint32_t height, | ||
304 | double ratio_code, int format, | ||
305 | int flags ){ | ||
306 | null_driver_t* this = (null_driver_t*) self; | ||
307 | opie_frame_t* frame = (opie_frame_t*)img; | ||
308 | |||
309 | #ifdef LOG | ||
310 | fprintf (stderr, "nullvideo: update_frame_format\n"); | ||
311 | #endif | ||
312 | |||
313 | flags &= VO_BOTH_FIELDS; | ||
314 | |||
315 | /* find out if we need to adapt this frame */ | ||
316 | |||
317 | if ((width != frame->sc.delivered_width) | ||
318 | || (height != frame->sc.delivered_height) | ||
319 | || (ratio_code != frame->sc.delivered_ratio) | ||
320 | || (flags != frame->flags) | ||
321 | || (format != frame->format) | ||
322 | || (this->sc.user_ratio != frame->sc.user_ratio) | ||
323 | || (this->gui_width != frame->sc.gui_width) | ||
324 | || (this->gui_height != frame->sc.gui_height)) { | ||
325 | |||
326 | frame->sc.delivered_width = width; | ||
327 | frame->sc.delivered_height = height; | ||
328 | frame->sc.delivered_ratio = ratio_code; | ||
329 | frame->flags = flags; | ||
330 | frame->format = format; | ||
331 | frame->sc.user_ratio = this->sc.user_ratio; | ||
332 | frame->sc.gui_width = this->gui_width; | ||
333 | frame->sc.gui_height = this->gui_height; | ||
334 | frame->sc.gui_pixel_aspect = 1.0; | ||
335 | |||
336 | |||
337 | null_frame_compute_ideal_size(this, frame); | ||
338 | null_frame_compute_rgb_size(this, frame); | ||
339 | null_frame_reallocate(this, frame, width, height, format); | ||
340 | |||
341 | #ifdef LOG | ||
342 | fprintf (stderr, "nullvideo: gui %dx%d delivered %dx%d output %dx%d\n", | ||
343 | frame->sc.gui_width, frame->sc.gui_height, | ||
344 | frame->sc.delivered_width, frame->sc.delivered_height, | ||
345 | frame->sc.output_width, frame->sc.output_height); | ||
346 | #endif | ||
347 | |||
348 | |||
349 | |||
286 | frame->stripe_height = 16 * frame->sc.output_height / frame->sc.delivered_height; | 350 | frame->stripe_height = 16 * frame->sc.output_height / frame->sc.delivered_height; |
287 | frame->bytes_per_line = frame->sc.output_width * this->bytes_per_pixel; | 351 | frame->bytes_per_line = frame->sc.output_width * this->bytes_per_pixel; |
288 | 352 | ||
289 | /* | 353 | /* |
290 | * set up colorspace converter | 354 | * set up colorspace converter |
291 | */ | 355 | */ |
356 | null_setup_colorspace_converter(frame, flags); | ||
292 | 357 | ||
293 | switch (flags) { | ||
294 | case VO_TOP_FIELD: | ||
295 | case VO_BOTTOM_FIELD: | ||
296 | frame->yuv2rgb->configure (frame->yuv2rgb, | ||
297 | frame->sc.delivered_width, | ||
298 | 16, | ||
299 | 2*frame->frame.pitches[0], | ||
300 | 2*frame->frame.pitches[1], | ||
301 | frame->sc.output_width, | ||
302 | frame->stripe_height, | ||
303 | frame->bytes_per_line*2); | ||
304 | frame->yuv_stride = frame->bytes_per_line*2; | ||
305 | break; | ||
306 | case VO_BOTH_FIELDS: | ||
307 | frame->yuv2rgb->configure (frame->yuv2rgb, | ||
308 | frame->sc.delivered_width, | ||
309 | 16, | ||
310 | frame->frame.pitches[0], | ||
311 | frame->frame.pitches[1], | ||
312 | frame->sc.output_width, | ||
313 | frame->stripe_height, | ||
314 | frame->bytes_per_line); | ||
315 | frame->yuv_stride = frame->bytes_per_line; | ||
316 | break; | ||
317 | } | ||
318 | #ifdef LOG | ||
319 | fprintf (stderr, "nullvideo: colorspace converter configured.\n"); | ||
320 | #endif | ||
321 | } | 358 | } |
322 | |||
323 | /* | 359 | /* |
324 | * reset dest pointers | 360 | * reset dest pointers |
325 | */ | 361 | */ |
326 | 362 | ||
327 | if (frame->data) { | 363 | if (frame->data) { |
328 | switch (flags) { | 364 | switch (flags) { |
329 | case VO_TOP_FIELD: | 365 | case VO_TOP_FIELD: |
330 | frame->rgb_dst = (uint8_t *)frame->data; | 366 | frame->rgb_dst = (uint8_t *)frame->data; |
331 | frame->stripe_inc = 2 * frame->stripe_height * frame->bytes_per_line; | 367 | frame->stripe_inc = 2 * frame->stripe_height * frame->bytes_per_line; |
332 | break; | 368 | break; |
333 | case VO_BOTTOM_FIELD: | 369 | case VO_BOTTOM_FIELD: |
334 | frame->rgb_dst = (uint8_t *)frame->data + frame->bytes_per_line ; | 370 | frame->rgb_dst = (uint8_t *)frame->data + frame->bytes_per_line ; |
335 | frame->stripe_inc = 2 * frame->stripe_height * frame->bytes_per_line; | 371 | frame->stripe_inc = 2 * frame->stripe_height * frame->bytes_per_line; |
336 | break; | 372 | break; |
337 | case VO_BOTH_FIELDS: | 373 | case VO_BOTH_FIELDS: |
338 | frame->rgb_dst = (uint8_t *)frame->data; | 374 | frame->rgb_dst = (uint8_t *)frame->data; |
339 | frame->stripe_inc = frame->stripe_height * frame->bytes_per_line; | 375 | frame->stripe_inc = frame->stripe_height * frame->bytes_per_line; |
340 | break; | 376 | break; |
377 | } | ||
341 | } | 378 | } |
342 | } | ||
343 | } | 379 | } |
344 | 380 | ||
345 | static void null_display_frame( vo_driver_t* self, vo_frame_t *frame_gen ){ | 381 | static void null_display_frame( vo_driver_t* self, vo_frame_t *frame_gen ){ |
346 | null_driver_t* this = (null_driver_t*) self; | 382 | null_driver_t* this = (null_driver_t*) self; |
@@ -363,16 +399,20 @@ static void null_display_frame( vo_driver_t* self, vo_frame_t *frame_gen ){ | |||
363 | /* blending related */ | 399 | /* blending related */ |
364 | static void null_overlay_clut_yuv2rgb (null_driver_t *this, | 400 | static void null_overlay_clut_yuv2rgb (null_driver_t *this, |
365 | vo_overlay_t *overlay, | 401 | vo_overlay_t *overlay, |
366 | opie_frame_t *frame) { | 402 | opie_frame_t *frame) { |
403 | this = this; | ||
404 | |||
405 | |||
367 | int i; | 406 | int i; |
368 | clut_t* clut = (clut_t*) overlay->color; | 407 | clut_t* clut = (clut_t*) overlay->color; |
369 | if (!overlay->rgb_clut) { | 408 | if (!overlay->rgb_clut) { |
370 | for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) { | 409 | for (i = 0; i < sizeof(overlay->color)/sizeof(overlay->color[0]); i++) { |
371 | *((uint32_t *)&clut[i]) = | 410 | *((uint32_t *)&clut[i]) = |
372 | frame->yuv2rgb->yuv2rgb_single_pixel_fun (frame->yuv2rgb, | 411 | frame->yuv2rgb-> |
373 | clut[i].y, clut[i].cb, | 412 | yuv2rgb_single_pixel_fun (frame->yuv2rgb, |
374 | clut[i].cr); | 413 | clut[i].y, clut[i].cb, |
414 | clut[i].cr); | ||
375 | } | 415 | } |
376 | overlay->rgb_clut++; | 416 | overlay->rgb_clut++; |
377 | } | 417 | } |
378 | if (!overlay->clip_rgb_clut) { | 418 | if (!overlay->clip_rgb_clut) { |
@@ -400,72 +440,135 @@ static void null_overlay_blend ( vo_driver_t *this_gen, vo_frame_t *frame_gen, | |||
400 | if( !overlay->rgb_clut || !overlay->clip_rgb_clut) | 440 | if( !overlay->rgb_clut || !overlay->clip_rgb_clut) |
401 | null_overlay_clut_yuv2rgb(this,overlay,frame); | 441 | null_overlay_clut_yuv2rgb(this,overlay,frame); |
402 | 442 | ||
403 | switch(this->bpp) { | 443 | switch(this->bpp) { |
404 | case 16: | 444 | case 16: |
405 | blend_rgb16( (uint8_t *)frame->data, overlay, | 445 | blend_rgb16((uint8_t *)frame->data, |
406 | frame->sc.output_width, frame->sc.output_height, | 446 | overlay, |
407 | frame->sc.delivered_width, frame->sc.delivered_height); | 447 | frame->sc.output_width, |
408 | break; | 448 | frame->sc.output_height, |
409 | case 24: | 449 | frame->sc.delivered_width, |
410 | blend_rgb24( (uint8_t *)frame->data, overlay, | 450 | frame->sc.delivered_height); |
411 | frame->sc.output_width, frame->sc.output_height, | 451 | break; |
412 | frame->sc.delivered_width, frame->sc.delivered_height); | 452 | case 24: |
413 | break; | 453 | blend_rgb24((uint8_t *)frame->data, |
414 | case 32: | 454 | overlay, |
415 | blend_rgb32( (uint8_t *)frame->data, overlay, | 455 | frame->sc.output_width, |
416 | frame->sc.output_width, frame->sc.output_height, | 456 | frame->sc.output_height, |
417 | frame->sc.delivered_width, frame->sc.delivered_height); | 457 | frame->sc.delivered_width, |
418 | break; | 458 | frame->sc.delivered_height); |
419 | default: | 459 | break; |
420 | /* It should never get here */ | 460 | case 32: |
421 | break; | 461 | blend_rgb32((uint8_t *)frame->data, |
462 | overlay, | ||
463 | frame->sc.output_width, | ||
464 | frame->sc.output_height, | ||
465 | frame->sc.delivered_width, | ||
466 | frame->sc.delivered_height); | ||
467 | break; | ||
468 | default: | ||
469 | /* It should never get here */ | ||
470 | break; | ||
422 | } | 471 | } |
423 | } | 472 | } |
424 | } | 473 | } |
425 | 474 | ||
426 | 475 | ||
427 | static int null_get_property( vo_driver_t* self, | 476 | static int null_get_property( vo_driver_t* self, int property ){ |
428 | int property ){ | 477 | #if 0 |
478 | null_driver_t *this = (null_driver_t *)self; | ||
479 | |||
480 | switch(property) | ||
481 | { | ||
482 | case VO_PROP_ASPECT_RATIO: | ||
483 | return this->sc.user_ratio; | ||
484 | case VO_PROP_BRIGHTNESS: | ||
485 | return this->yuv2rgb_brightness; | ||
486 | case VO_PROP_WINDOW_WIDTH: | ||
487 | return this->sc.gui_width; | ||
488 | case VO_PROP_WINDOW_HEIGHT: | ||
489 | return this->sc.gui_height; | ||
490 | default: | ||
491 | break; | ||
492 | } | ||
493 | #else | ||
494 | property = property; | ||
495 | self = self; | ||
496 | #endif | ||
497 | |||
429 | return 0; | 498 | return 0; |
430 | } | 499 | } |
431 | static int null_set_property( vo_driver_t* self, | 500 | static int null_set_property( vo_driver_t* self, int property, |
432 | int property, | ||
433 | int value ){ | 501 | int value ){ |
502 | #if 0 | ||
503 | null_driver_t *this = (null_driver_t *)self; | ||
504 | |||
505 | switch(property) | ||
506 | { | ||
507 | case VO_PROP_ASPECT_RATIO: | ||
508 | if(value>=XINE_VO_ASPECT_NUM_RATIOS) | ||
509 | value = XINE_VO_ASPECT_AUTO; | ||
510 | this->sc.user_ratio = value; | ||
511 | break; | ||
512 | case VO_PROP_BRIGHTNESS: | ||
513 | this->yuv2rgb_brightness = value; | ||
514 | this->yuv2rgb_factory-> | ||
515 | set_csc_levels(this->yuv2rgb_factory, value, 128, 128); | ||
516 | break; | ||
517 | default: | ||
518 | break; | ||
519 | } | ||
520 | #else | ||
521 | self = self; | ||
522 | property = property; | ||
523 | #endif | ||
524 | |||
434 | return value; | 525 | return value; |
435 | } | 526 | } |
436 | static void null_get_property_min_max( vo_driver_t* self, | 527 | static void null_get_property_min_max( vo_driver_t* self, |
437 | int property, int *min, | 528 | int property, int *min, |
438 | int *max ){ | 529 | int *max ){ |
530 | self = self; | ||
531 | property = property; | ||
532 | |||
439 | *max = 0; | 533 | *max = 0; |
440 | *min = 0; | 534 | *min = 0; |
441 | } | 535 | } |
442 | static int null_gui_data_exchange( vo_driver_t* self, | 536 | static int null_gui_data_exchange( vo_driver_t* self, |
443 | int data_type, | 537 | int data_type, |
444 | void *data ){ | 538 | void *data ){ |
539 | self = self; | ||
540 | data_type = data_type; | ||
541 | data = data; | ||
542 | |||
445 | return 0; | 543 | return 0; |
446 | } | 544 | } |
447 | 545 | ||
448 | static void null_dispose ( vo_driver_t* self ){ | 546 | static void null_dispose ( vo_driver_t* self ){ |
449 | null_driver_t* this = (null_driver_t*)self; | 547 | null_driver_t* this = (null_driver_t*)self; |
450 | free ( this ); | 548 | free ( this ); |
451 | } | 549 | } |
452 | static int null_redraw_needed( vo_driver_t* self ){ | 550 | static int null_redraw_needed( vo_driver_t* self ){ |
453 | return 0; | 551 | self = self; |
552 | |||
553 | return 0; | ||
454 | } | 554 | } |
455 | 555 | ||
456 | 556 | ||
457 | xine_vo_driver_t* init_video_out_plugin( xine_t *xine, | 557 | xine_video_port_t* init_video_out_plugin( xine_t *xine, |
458 | void* video, | 558 | void* video, |
459 | display_xine_frame_t frameDisplayFunc, | 559 | display_xine_frame_t frameDisplayFunc, |
460 | void *userData ){ | 560 | void *userData ){ |
561 | video = video; | ||
562 | |||
563 | |||
461 | null_driver_t *vo; | 564 | null_driver_t *vo; |
462 | vo = (null_driver_t*)malloc( sizeof(null_driver_t ) ); | 565 | vo = (null_driver_t*)malloc( sizeof(null_driver_t ) ); |
463 | 566 | ||
464 | /* memset? */ | 567 | /* memset? */ |
465 | memset(vo,0, sizeof(null_driver_t ) ); | 568 | memset(vo,0, sizeof(null_driver_t ) ); |
466 | 569 | ||
467 | vo_scale_init (&vo->sc, 0, 0, xine->config); | 570 | _x_vo_scale_init (&vo->sc, 0, 0, xine->config); |
468 | 571 | ||
469 | vo->sc.gui_pixel_aspect = 1.0; | 572 | vo->sc.gui_pixel_aspect = 1.0; |
470 | 573 | ||
471 | vo->m_show_video = 0; // false | 574 | vo->m_show_video = 0; // false |
@@ -490,31 +593,18 @@ xine_vo_driver_t* init_video_out_plugin( xine_t *xine, | |||
490 | vo->vo_driver.redraw_needed = null_redraw_needed; | 593 | vo->vo_driver.redraw_needed = null_redraw_needed; |
491 | 594 | ||
492 | 595 | ||
493 | /* capabilities */ | 596 | /* capabilities */ |
494 | vo->m_capabilities = /* VO_CAP_COPIES_IMAGE | */ VO_CAP_YUY2 | VO_CAP_YV12; | 597 | vo->m_capabilities = VO_CAP_YUY2 | VO_CAP_YV12; |
495 | vo->yuv2rgb_factory = yuv2rgb_factory_init (MODE_16_RGB, vo->yuv2rgb_swap, | 598 | vo->yuv2rgb_factory = yuv2rgb_factory_init (MODE_16_RGB, vo->yuv2rgb_swap, |
496 | vo->yuv2rgb_cmap); | 599 | vo->yuv2rgb_cmap); |
497 | 600 | ||
498 | vo->caller = userData; | 601 | vo->caller = userData; |
499 | vo->frameDis = frameDisplayFunc; | 602 | vo->frameDis = frameDisplayFunc; |
500 | 603 | ||
501 | /* return ( vo_driver_t*) vo; */ | 604 | return _x_vo_new_port(xine, &vo->vo_driver, 0); |
502 | return vo_new_port( xine, ( vo_driver_t* )vo, 0 ); | ||
503 | } | 605 | } |
504 | 606 | ||
505 | #if 0 | ||
506 | static vo_info_t vo_info_null = { | ||
507 | 5, | ||
508 | XINE_VISUAL_TYPE_FB | ||
509 | }; | ||
510 | |||
511 | vo_info_t *get_video_out_plugin_info(){ | ||
512 | vo_info_null.description = ("xine video output plugin using null device"); | ||
513 | return &vo_info_null; | ||
514 | } | ||
515 | |||
516 | #endif | ||
517 | 607 | ||
518 | /* this is special for this device */ | 608 | /* this is special for this device */ |
519 | /** | 609 | /** |
520 | * We know that we will be controled by the XINE LIB++ | 610 | * We know that we will be controled by the XINE LIB++ |
@@ -563,10 +653,9 @@ void null_set_mode( xine_vo_driver_t* self, int depth, int rgb ) { | |||
563 | 653 | ||
564 | this->bytes_per_pixel = (depth + 7 ) / 8; | 654 | this->bytes_per_pixel = (depth + 7 ) / 8; |
565 | this->bpp = this->bytes_per_pixel * 8; | 655 | this->bpp = this->bytes_per_pixel * 8; |
566 | this->depth = depth; | 656 | this->depth = depth; |
567 | printf("depth %d %d\n", depth, this->bpp); | 657 | |
568 | printf("pixeltype %d\n", rgb ); | ||
569 | switch ( this->depth ) { | 658 | switch ( this->depth ) { |
570 | case 32: | 659 | case 32: |
571 | if( rgb == 0 ) | 660 | if( rgb == 0 ) |
572 | this->yuv2rgb_mode = MODE_32_RGB; | 661 | this->yuv2rgb_mode = MODE_32_RGB; |
@@ -627,16 +716,20 @@ void null_preload_decoders( xine_stream_t *stream ) | |||
627 | static const uint32_t preloadedVideoDecoders[] = { BUF_VIDEO_MPEG, BUF_VIDEO_MPEG4, BUF_VIDEO_DIVX5 }; | 716 | static const uint32_t preloadedVideoDecoders[] = { BUF_VIDEO_MPEG, BUF_VIDEO_MPEG4, BUF_VIDEO_DIVX5 }; |
628 | static const uint8_t preloadedVideoDecoderCount = sizeof( preloadedVideoDecoders ) / sizeof( preloadedVideoDecoders[ 0 ] ); | 717 | static const uint8_t preloadedVideoDecoderCount = sizeof( preloadedVideoDecoders ) / sizeof( preloadedVideoDecoders[ 0 ] ); |
629 | 718 | ||
630 | uint8_t i; | 719 | uint8_t i; |
720 | #if 0 | ||
631 | 721 | ||
632 | for ( i = 0; i < preloadedAudioDecoderCount; ++i ) { | 722 | for ( i = 0; i < preloadedAudioDecoderCount; ++i ) { |
633 | audio_decoder_t *decoder = get_audio_decoder( stream, ( preloadedAudioDecoders[ i ] >> 16 ) & 0xff ); | 723 | audio_decoder_t *decoder = get_audio_decoder( stream, ( preloadedAudioDecoders[ i ] >> 16 ) & 0xff ); |
724 | decoder = decoder; | ||
634 | /* free_audio_decoder( stream, decoder ); */ | 725 | /* free_audio_decoder( stream, decoder ); */ |
635 | } | 726 | } |
636 | 727 | ||
637 | for ( i = 0; i < preloadedVideoDecoderCount; ++i ) { | 728 | for ( i = 0; i < preloadedVideoDecoderCount; ++i ) { |
638 | video_decoder_t *decoder = get_video_decoder( stream, ( preloadedVideoDecoders[ i ] >> 16 ) & 0xff ); | 729 | video_decoder_t *decoder = get_video_decoder( stream, ( preloadedVideoDecoders[ i ] >> 16 ) & 0xff ); |
730 | decoder = decoder; | ||
639 | /* free_video_decoder( stream, decoder ); */ | 731 | /* free_video_decoder( stream, decoder ); */ |
640 | } | 732 | } |
733 | #endif | ||
641 | } | 734 | } |
642 | 735 | ||