xine-lib 1.2.11
xine.h
Go to the documentation of this file.
1/*
2 * Copyright (C) 2000-2020 the xine project
3 *
4 * This file is part of xine, a free video player.
5 *
6 * xine is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * xine is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 *
20 * public xine-lib (libxine) interface and documentation
21 *
22 *
23 * some programming guidelines about this api:
24 * -------------------------------------------
25 *
26 * (1) libxine has (per stream instance) a fairly static memory
27 * model
28 * (2) as a rule of thumb, never free() or realloc() any pointers
29 * returned by the xine engine (unless stated otherwise)
30 * or, in other words:
31 * do not free() stuff you have not malloc()ed
32 * (3) xine is multi-threaded, make sure your programming environment
33 * can handle this.
34 * for x11-related stuff this means that you either have to properly
35 * use xlockdisplay() or use two seperate connections to the x-server
36 *
37 */
38/*_x_ Lines formatted like this one are xine-lib developer comments. */
39/*_x_ They will be removed from the installed version of this header. */
40
41#ifndef HAVE_XINE_H
42#define HAVE_XINE_H
43
44#ifdef __cplusplus
45extern "C" {
46#endif
47
48#include <stdarg.h>
49#include <sys/time.h>
50#include <sys/types.h>
51
52#if defined(WIN32) && !defined(XINE_COMPILE)
53#include <windows.h>
54#endif
55
56#include <xine/os_types.h>
57#include <xine/attributes.h>
58#include <xine/version.h>
59
60/* This enables some experimental features. These are not part of the
61 * official libxine API, so use them only, if you absolutely need them.
62 * Although we make efforts to keep even this part of the API as stable
63 * as possible, this is not guaranteed. Incompatible changes can occur.
64 */
65/* #define XINE_ENABLE_EXPERIMENTAL_FEATURES */
66
67/* This disables some deprecated features. These are still part of the
68 * official libxine API and you may still use them. During the current
69 * major release series, these will always be available and will stay
70 * compatible. However, removal is likely to occur as soon as possible.
71 */
72/* #define XINE_DISABLE_DEPRECATED_FEATURES */
73
74
75/*********************************************************************
76 * xine opaque data types *
77 *********************************************************************/
78
79typedef struct xine_s xine_t;
83
84/*********************************************************************
85 * global engine handling *
86 *********************************************************************/
87
88/*
89 * version information
90 */
91
92/* dynamic info from actually linked libxine */
94void xine_get_version (int *major, int *minor, int *sub) XINE_PROTECTED;
95
96/* compare given version to libxine version,
97 return 1 if compatible, 0 otherwise */
98int xine_check_version (int major, int minor, int sub) XINE_PROTECTED;
99
100/*
101 * pre-init the xine engine
102 *
103 * will first malloc and init a xine_t, create an empty config
104 * system, then scan through all installed plugins and add them
105 * to an internal list for later use.
106 *
107 * to fully init the xine engine, you have to load config values
108 * (either using your own storage method and calling
109 * xine_config_register_entry, or by using the xine_load_config
110 * utility function - see below) and then call xine_init
111 *
112 * the only proper way to shut down the xine engine is to
113 * call xine_exit() - do not try to free() the xine pointer
114 * yourself and do not try to access any internal data structures
115 */
117
118/* allow the setting of some flags before xine_init
119 * FIXME-ABI: this is currently GLOBAL
120 */
122#define XINE_FLAG_NO_WRITE_CACHE 1
123
124/*
125 * post_init the xine engine
126 */
127void xine_init (xine_t *self) XINE_PROTECTED;
128
129/*
130 * helper functions to find and init audio/video drivers
131 * from xine's plugin collection
132 *
133 * id : identifier of the driver, may be NULL for auto-detection
134 * data : special data struct for ui/driver communications, depends
135 * on driver
136 * visual: video driver flavor selector, constants see below
137 *
138 * both functions may return NULL if driver failed to load, was not
139 * found ...
140 *
141 * use xine_close_audio/video_driver() to close loaded drivers
142 * and free resources allocated by them
143 */
144xine_audio_port_t *xine_open_audio_driver (xine_t *self, const char *id,
145 const void *data) XINE_PROTECTED;
146xine_video_port_t *xine_open_video_driver (xine_t *self, const char *id,
147 int visual, const void *data) XINE_PROTECTED;
148
151
152/* valid visual types */
153#define XINE_VISUAL_TYPE_NONE 0
154#define XINE_VISUAL_TYPE_X11 1
155#define XINE_VISUAL_TYPE_X11_2 10
156#define XINE_VISUAL_TYPE_AA 2
157#define XINE_VISUAL_TYPE_FB 3
158#define XINE_VISUAL_TYPE_GTK 4
159#define XINE_VISUAL_TYPE_DFB 5
160#define XINE_VISUAL_TYPE_PM 6 /* used by the OS/2 port */
161#define XINE_VISUAL_TYPE_DIRECTX 7 /* used by the win32/msvc port */
162#define XINE_VISUAL_TYPE_CACA 8
163#define XINE_VISUAL_TYPE_MACOSX 9
164#define XINE_VISUAL_TYPE_XCB 11
165#define XINE_VISUAL_TYPE_RAW 12
166#define XINE_VISUAL_TYPE_WAYLAND 13
167
168/*
169 * free all resources, close all plugins, close engine.
170 * self pointer is no longer valid after this call.
171 */
172void xine_exit (xine_t *self) XINE_PROTECTED;
173
174
175/*********************************************************************
176 * stream handling *
177 *********************************************************************/
178
179/*
180 * create a new stream for media playback/access
181 *
182 * returns xine_stream_t* if OK,
183 * NULL on error (use xine_get_error for details)
184 *
185 * the only proper way to free the stream pointer returned by this
186 * function is to call xine_dispose() on it. do not try to access any
187 * fields in xine_stream_t, they're all private and subject to change
188 * without further notice.
189 */
192
193/*
194 * A side stream is like a side car on a bike. It has its own mrl, input, and demux.
195 * Everything else is handled by the master (play, seek, pause, close, dispose).
196 * This is intended for streams who have separate mrls for audio, video, and subtitle.
197 * Index 0 just returns the master itself, 1 ... 3 are free for side mrls. */
198#define XINE_SIDE_STREAMS 1
200
201/*
202 * Make one stream the slave of another.
203 * This establishes a binary master slave relation on streams, where
204 * certain operations (specified by parameter "affection") on the master
205 * stream are also applied to the slave stream.
206 * If you want more than one stream to react to one master, you have to
207 * apply the calls in a top down way:
208 * xine_stream_master_slave(stream1, stream2, 3);
209 * xine_stream_master_slave(stream2, stream3, 3);
210 * This will make stream1 affect stream2 and stream2 affect stream3, so
211 * effectively, operations on stream1 propagate to stream2 and 3.
212 *
213 * Please note that subsequent master_slave calls on the same streams
214 * will overwrite their previous master/slave setting.
215 * Be sure to not mess around.
216 *
217 * returns 1 on success, 0 on failure
218 */
220 int affection) XINE_PROTECTED;
221
222/* affection is some of the following ORed together: */
223/* playing the master plays the slave */
224#define XINE_MASTER_SLAVE_PLAY (1<<0)
225/* slave stops on master stop */
226#define XINE_MASTER_SLAVE_STOP (1<<1)
227/* slave is synced to master's speed */
228#define XINE_MASTER_SLAVE_SPEED (1<<2)
229
230/*
231 * open a stream
232 *
233 * look for input / demux / decoder plugins, find out about the format
234 * see if it is supported, set up internal buffers and threads
235 *
236 * returns 1 if OK, 0 on error (use xine_get_error for details)
237 */
238int xine_open (xine_stream_t *stream, const char *mrl) XINE_PROTECTED;
239
242#define XINE_KEYFRAMES 1
244typedef struct {
245 int msecs;
248
261
268
269/*
270 * play a stream from a given position
271 *
272 * start_pos: 0..65535
273 * start_time: milliseconds
274 * if both start position parameters are != 0 start_pos will be used
275 * for non-seekable streams both values will be ignored
276 *
277 * returns 1 if OK, 0 on error (use xine_get_error for details)
278 */
279int xine_play (xine_stream_t *stream, int start_pos, int start_time) XINE_PROTECTED;
280
281/*
282 * stop stream playback
283 * xine_stream_t stays valid for new xine_open or xine_play
284 */
286
287/*
288 * stop stream playback, free all stream-related resources
289 * xine_stream_t stays valid for new xine_open
290 */
292
293/*
294 * ask current/recent input plugin to eject media - may or may not work,
295 * depending on input plugin capabilities
296 */
298
299/*
300 * stop playback, dispose all stream-related resources
301 * xine_stream_t no longer valid when after this
302 */
304
305/*
306 * set/get engine parameters.
307 */
308void xine_engine_set_param(xine_t *self, int param, int value) XINE_PROTECTED;
309int xine_engine_get_param(xine_t *self, int param) XINE_PROTECTED;
310
311#define XINE_ENGINE_PARAM_VERBOSITY 1
312
313/*
314 * set/get xine stream parameters
315 * e.g. playback speed, constants see below
316 */
317void xine_set_param (xine_stream_t *stream, int param, int value) XINE_PROTECTED;
318int xine_get_param (xine_stream_t *stream, int param) XINE_PROTECTED;
319
320/*
321 * xine stream parameters
322 */
323#define XINE_PARAM_SPEED 1 /* see below */
324#define XINE_PARAM_AV_OFFSET 2 /* unit: 1/90000 sec */
325#define XINE_PARAM_AUDIO_CHANNEL_LOGICAL 3 /* -1 => auto, -2 => off */
326#define XINE_PARAM_SPU_CHANNEL 4
327#define XINE_PARAM_VIDEO_CHANNEL 5
328#define XINE_PARAM_AUDIO_VOLUME 6 /* 0..100 */
329#define XINE_PARAM_AUDIO_MUTE 7 /* 1=>mute, 0=>unmute */
330#define XINE_PARAM_AUDIO_COMPR_LEVEL 8 /* <100=>off, % compress otherw*/
331#define XINE_PARAM_AUDIO_AMP_LEVEL 9 /* 0..200, 100=>100% (default) */
332#define XINE_PARAM_AUDIO_REPORT_LEVEL 10 /* 1=>send events, 0=> don't */
333#define XINE_PARAM_VERBOSITY 11 /* control console output */
334#define XINE_PARAM_SPU_OFFSET 12 /* unit: 1/90000 sec */
335#define XINE_PARAM_IGNORE_VIDEO 13 /* disable video decoding */
336#define XINE_PARAM_IGNORE_AUDIO 14 /* disable audio decoding */
337#define XINE_PARAM_IGNORE_SPU 15 /* disable spu decoding */
338#define XINE_PARAM_BROADCASTER_PORT 16 /* 0: disable, x: server port */
339#define XINE_PARAM_METRONOM_PREBUFFER 17 /* unit: 1/90000 sec */
340#define XINE_PARAM_EQ_30HZ 18 /* equalizer gains -100..100 */
341#define XINE_PARAM_EQ_60HZ 19 /* equalizer gains -100..100 */
342#define XINE_PARAM_EQ_125HZ 20 /* equalizer gains -100..100 */
343#define XINE_PARAM_EQ_250HZ 21 /* equalizer gains -100..100 */
344#define XINE_PARAM_EQ_500HZ 22 /* equalizer gains -100..100 */
345#define XINE_PARAM_EQ_1000HZ 23 /* equalizer gains -100..100 */
346#define XINE_PARAM_EQ_2000HZ 24 /* equalizer gains -100..100 */
347#define XINE_PARAM_EQ_4000HZ 25 /* equalizer gains -100..100 */
348#define XINE_PARAM_EQ_8000HZ 26 /* equalizer gains -100..100 */
349#define XINE_PARAM_EQ_16000HZ 27 /* equalizer gains -100..100 */
350#define XINE_PARAM_AUDIO_CLOSE_DEVICE 28 /* force closing audio device */
351#define XINE_PARAM_AUDIO_AMP_MUTE 29 /* 1=>mute, 0=>unmute */
352#define XINE_PARAM_FINE_SPEED 30 /* 1.000.000 => normal speed */
353#define XINE_PARAM_EARLY_FINISHED_EVENT 31 /* send event when demux finish*/
354#define XINE_PARAM_GAPLESS_SWITCH 32 /* next stream only gapless swi*/
355#define XINE_PARAM_DELAY_FINISHED_EVENT 33 /* 1/10sec,0=>disable,-1=>forev*/
356
357/*
358 * speed values for XINE_PARAM_SPEED parameter.
359 *
360 * alternatively, one may use XINE_PARAM_FINE_SPEED for greater
361 * control of the speed value, where:
362 * XINE_PARAM_SPEED / 4 <-> XINE_PARAM_FINE_SPEED / 1000000
363 */
364#define XINE_SPEED_PAUSE 0
365#define XINE_SPEED_SLOW_4 1
366#define XINE_SPEED_SLOW_2 2
367#define XINE_SPEED_NORMAL 4
368#define XINE_SPEED_FAST_2 8
369#define XINE_SPEED_FAST_4 16
370
371/* normal speed value for XINE_PARAM_FINE_SPEED parameter */
372#define XINE_FINE_SPEED_NORMAL 1000000
373
374/* video parameters */
375#define XINE_PARAM_VO_DEINTERLACE 0x01000000 /* bool */
376#define XINE_PARAM_VO_ASPECT_RATIO 0x01000001 /* see below */
377#define XINE_PARAM_VO_HUE 0x01000002 /* 0..65535 */
378#define XINE_PARAM_VO_SATURATION 0x01000003 /* 0..65535 */
379#define XINE_PARAM_VO_CONTRAST 0x01000004 /* 0..65535 */
380#define XINE_PARAM_VO_BRIGHTNESS 0x01000005 /* 0..65535 */
381#define XINE_PARAM_VO_GAMMA 0x0100000c /* 0..65535 */
382#define XINE_PARAM_VO_ZOOM_X 0x01000008 /* percent */
383#define XINE_PARAM_VO_ZOOM_Y 0x0100000d /* percent */
384#define XINE_PARAM_VO_PAN_SCAN 0x01000009 /* bool */
385#define XINE_PARAM_VO_TVMODE 0x0100000a /* ??? */
386#define XINE_PARAM_VO_WINDOW_WIDTH 0x0100000f /* readonly */
387#define XINE_PARAM_VO_WINDOW_HEIGHT 0x01000010 /* readonly */
388#define XINE_PARAM_VO_SHARPNESS 0x01000018 /* 0..65535 */
389#define XINE_PARAM_VO_NOISE_REDUCTION 0x01000019 /* 0..65535 */
390#define XINE_PARAM_VO_CROP_LEFT 0x01000020 /* crop frame pixels */
391#define XINE_PARAM_VO_CROP_RIGHT 0x01000021 /* crop frame pixels */
392#define XINE_PARAM_VO_CROP_TOP 0x01000022 /* crop frame pixels */
393#define XINE_PARAM_VO_CROP_BOTTOM 0x01000023 /* crop frame pixels */
394#define XINE_PARAM_VO_SINGLE_STEP 0x01000024 /* 1 = "advance to next frame, then pause" */
395
396#define XINE_VO_ZOOM_STEP 100
397#define XINE_VO_ZOOM_MAX 400
398#define XINE_VO_ZOOM_MIN -85
399
400/* possible ratios for XINE_PARAM_VO_ASPECT_RATIO */
401#define XINE_VO_ASPECT_AUTO 0
402#define XINE_VO_ASPECT_SQUARE 1 /* 1:1 */
403#define XINE_VO_ASPECT_4_3 2 /* 4:3 */
404#define XINE_VO_ASPECT_ANAMORPHIC 3 /* 16:9 */
405#define XINE_VO_ASPECT_DVB 4 /* 2.11:1 */
406#define XINE_VO_ASPECT_NUM_RATIOS 5
407#ifndef XINE_DISABLE_DEPRECATED_FEATURES
408#define XINE_VO_ASPECT_PAN_SCAN 41
409#define XINE_VO_ASPECT_DONT_TOUCH 42
410#endif
411
412/* stream format detection strategies */
413
414/* recognize stream type first by content then by extension. */
415#define XINE_DEMUX_DEFAULT_STRATEGY 0
416/* recognize stream type first by extension then by content. */
417#define XINE_DEMUX_REVERT_STRATEGY 1
418/* recognize stream type by content only. */
419#define XINE_DEMUX_CONTENT_STRATEGY 2
420/* recognize stream type by extension only. */
421#define XINE_DEMUX_EXTENSION_STRATEGY 3
422
423/* verbosity settings */
424#define XINE_VERBOSITY_NONE 0
425#define XINE_VERBOSITY_LOG 1
426#define XINE_VERBOSITY_DEBUG 2
427
428/*
429 * snapshot function
430 *
431 * image format can be YUV 4:2:0 or 4:2:2
432 * will copy the image data into memory that <img> points to
433 * (interleaved for yuv 4:2:2 or planary for 4:2:0)
434 *
435 * xine_get_current_frame() requires that <img> must be able
436 * to hold the image data. Use a NULL pointer to retrieve the
437 * necessary parameters for calculating the buffer size. Be
438 * aware that the image can change between two successive calls
439 * so you better pause the stream.
440 *
441 * xine_get_current_frame_s() requires to specify the buffer
442 * size and it returns the needed / used size. It won't copy
443 * image data into a too small buffer.
444 *
445 * xine_get_current_frame_alloc() takes care of allocating
446 * a buffer on its own, so image data can be retrieved by
447 * a single call without the need to pause the stream.
448 *
449 * xine_get_current_frame_data() passes the parameters of the
450 * previously mentioned functions plus further information in
451 * a structure and can work like the _s or _alloc function
452 * respectively depending on the passed flags.
453 *
454 * all functions return 1 on success, 0 failure.
455 */
457 int *width, int *height,
458 int *ratio_code, int *format,
459 uint8_t *img) XINE_PROTECTED XINE_DEPRECATED;
460
462 int *width, int *height,
463 int *ratio_code, int *format,
464 uint8_t *img, int *img_size) XINE_PROTECTED;
465
467 int *width, int *height,
468 int *ratio_code, int *format,
469 uint8_t **img, int *img_size) XINE_PROTECTED;
470
472
474 int width;
484 uint8_t *img;
485};
486
487#define XINE_FRAME_DATA_ALLOCATE_IMG (1<<0)
488
491 int flags) XINE_PROTECTED;
492
493/* xine image formats */
494#define XINE_IMGFMT_YV12 (('2'<<24)|('1'<<16)|('V'<<8)|'Y')
495#define XINE_IMGFMT_YUY2 (('2'<<24)|('Y'<<16)|('U'<<8)|'Y')
496#define XINE_IMGFMT_XVMC (('C'<<24)|('M'<<16)|('v'<<8)|'X')
497#define XINE_IMGFMT_XXMC (('C'<<24)|('M'<<16)|('x'<<8)|'X')
498#define XINE_IMGFMT_VDPAU (('A'<<24)|('P'<<16)|('D'<<8)|'V')
499#define XINE_IMGFMT_VAAPI (('P'<<24)|('A'<<16)|('A'<<8)|'V')
500
501/* get current xine's virtual presentation timestamp (1/90000 sec)
502 * note: this is mostly internal data.
503 * one can use vpts with xine_osd_show() and xine_osd_hide().
504 */
506
507
508/*
509 * Continuous video frame grabbing feature.
510 *
511 * In opposite to the 'xine_get_current_frame' based snapshot function this grabbing
512 * feature allow continuous grabbing of last or next displayed video frame.
513 * Grabbed video frames are returned in simple three byte RGB format.
514 *
515 * Depending on the capabilities of the used video output driver video image data is
516 * taken as close as possible at the end of the video processing chain. Thus a returned
517 * video image could contain the blended OSD data, is deinterlaced, cropped and scaled
518 * and video properties like hue, sat could be applied.
519 * If a video output driver does not have a decent grabbing implementation then there
520 * is a generic fallback feature that grabs the video frame as they are taken from the video
521 * display queue (like the xine_get_current_frame' function).
522 * In this case color correct conversation to a RGB image incorporating source cropping
523 * and scaling to the requested grab size is also supported.
524 *
525 * The caller must first request a new video grab frame using the public 'xine_new_grab_video_frame'
526 * function. Then the caller should populate the frame with the wanted source cropping, grab image
527 * size and control flags. After that grab requests could be done by calling the supplied grab() feature
528 * of the frame. At the end a call to the supplied dispose() feature of the frame releases all needed
529 * resources.
530 * The caller should have acquired a port ticket while calling these features.
531 *
532 */
533#define HAVE_XINE_GRAB_VIDEO_FRAME 1
534
535/*
536 * frame structure used for grabbing video frames of format RGB.
537 */
540 /*
541 * grab last/next displayed image.
542 * returns 0 if grab is successful, 1 on timeout and -1 on error
543 */
545
546 /*
547 * free all resources.
548 */
550
551 /*
552 * Cropping of source image. Has to be specified by caller.
553 */
558
559 /*
560 * Parameters of returned RGB image.
561 * Caller can specify wanted frame size giving width and/or height a value > 0.
562 * In this case the grabbed image is scaled to the requested size.
563 * Otherwise the grab function returns the actual size of the grabbed image
564 * in width/height without scaling the image.
565 */
566 int width, height; /* requested/returned size of image */
567 uint8_t *img; /* returned RGB image data taking three bytes per pixel */
568 int64_t vpts; /* virtual presentation timestamp (1/90000 sec) of returned frame */
569
570 int timeout; /* Max. time to wait for next displayed frame in milliseconds */
571 int flags; /* Controlling flags. See XINE_GRAB_VIDEO_FRAME_FLAGS_* definitions */
572};
573
574#define XINE_GRAB_VIDEO_FRAME_FLAGS_CONTINUOUS 0x01 /* optimize resource allocation for continuous frame grabbing */
575#define XINE_GRAB_VIDEO_FRAME_FLAGS_WAIT_NEXT 0x02 /* wait for next display frame instead of using last displayed frame */
576
577#define XINE_GRAB_VIDEO_FRAME_DEFAULT_TIMEOUT 500
578
579/*
580 * Allocate new grab video frame. Returns NULL on error.
581 */
583
584
585/*********************************************************************
586 * media processing *
587 *********************************************************************/
588
589#ifdef XINE_ENABLE_EXPERIMENTAL_FEATURES
590
591/*
592 * access to decoded audio and video frames from a stream
593 * these functions are intended to provide the basis for
594 * re-encoding and other video processing applications
595 *
596 * note that the xine playback engine will block when
597 * rendering to a framegrab port: to unblock the stream,
598 * you must fetch the frames manually with the
599 * xine_get_next_* functions. this ensures that a
600 * framegrab port is guaranteed to never miss a frame.
601 *
602 */
603
605
606typedef struct {
607
608 int64_t vpts; /* timestamp 1/90000 sec for a/v sync */
609 int64_t duration;
610 double aspect_ratio;
611 int width, height;
612 int colorspace; /* XINE_IMGFMT_* */
613
614 int pos_stream; /* bytes from stream start */
615 int pos_time; /* milliseconds */
616
617 int frame_number; /* frame number (may be unknown) */
618
619 uint8_t *data;
620 void *xine_frame; /* used internally by xine engine */
621} xine_video_frame_t;
622
624 xine_video_frame_t *frame) XINE_PROTECTED;
625
626void xine_free_video_frame (xine_video_port_t *port, xine_video_frame_t *frame) XINE_PROTECTED;
627
629
630typedef struct {
631
632 int64_t vpts; /* timestamp 1/90000 sec for a/v sync */
633 int num_samples;
634 int sample_rate;
635 int num_channels;
636 int bits_per_sample; /* per channel */
637
638 uint8_t *data;
639 void *xine_frame; /* used internally by xine engine */
640
641 off_t pos_stream; /* bytes from stream start */
642 int pos_time; /* milliseconds */
643} xine_audio_frame_t;
644
646 xine_audio_frame_t *frame) XINE_PROTECTED;
647
648void xine_free_audio_frame (xine_audio_port_t *port, xine_audio_frame_t *frame) XINE_PROTECTED;
649
650#endif
651
652
653/*********************************************************************
654 * post plugin handling *
655 *********************************************************************/
656
657/*
658 * post effect plugin functions
659 *
660 * after the data leaves the decoder it can pass an arbitrary tree
661 * of post plugins allowing for effects to be applied to the video
662 * frames/audio buffers before they reach the output stage
663 */
664
666
668
669 /* a NULL-terminated array of audio input ports this post plugin
670 * provides; you can hand these to other post plugin's outputs or
671 * pass them to the initialization of streams
672 */
674
675 /* a NULL-terminated array of video input ports this post plugin
676 * provides; you can hand these to other post plugin's outputs or
677 * pass them to the initialization of streams
678 */
680
681 /* the type of the post plugin
682 * one of XINE_POST_TYPE_* can be used here
683 */
684 int type;
685
686};
687
688/*
689 * initialize a post plugin
690 *
691 * returns xine_post_t* on success, NULL on failure
692 *
693 * Initializes the post plugin with the given name and connects its
694 * outputs to the NULL-terminated arrays of audio and video ports.
695 * Some plugins also care about the number of inputs you request
696 * (e.g. mixer plugins), others simply ignore this number.
697 */
698xine_post_t *xine_post_init(xine_t *xine, const char *name,
699 int inputs,
700 xine_audio_port_t **audio_target,
701 xine_video_port_t **video_target) XINE_PROTECTED;
702
703/* get a list of all available post plugins */
704const char *const *xine_list_post_plugins(xine_t *xine) XINE_PROTECTED;
705
706/* get a list of all post plugins of one type */
707const char *const *xine_list_post_plugins_typed(xine_t *xine, uint32_t type) XINE_PROTECTED;
708
709/*
710 * post plugin input/output
711 *
712 * These structures encapsulate inputs/outputs for post plugins
713 * to transfer arbitrary data. Frontends can also provide inputs
714 * and outputs and connect them to post plugins to exchange data
715 * with them.
716 */
717
720
722
723 /* the name identifying this input */
724 const char *name;
725
726 /* the data pointer; input is directed to this memory location,
727 * so you simply access the pointer to access the input data */
728 void *data;
729
730 /* the datatype of this input, use one of XINE_POST_DATA_* here */
731 int type;
732
733};
734
736
737 /* the name identifying this output */
738 const char *name;
739
740 /* the data pointer; output should be directed to this memory location,
741 * so in the easy case you simply write through the pointer */
742 void *data;
743
744 /* this function is called, when the output should be redirected
745 * to another input, you sould set the data pointer to direct
746 * any output to this new input;
747 * a special situation is, when this function is called with a NULL
748 * argument: in this case you should disconnect the data pointer
749 * from any output and if necessary to avoid writing to some stray
750 * memory you should make it point to some dummy location,
751 * returns 1 on success, 0 on failure;
752 * if you do not implement rewiring, set this to NULL */
753 int (*rewire) (xine_post_out_t *self, void *data);
754
755 /* the datatype of this output, use one of XINE_POST_DATA_* here */
756 int type;
757
758};
759
760/* get a list of all inputs of a post plugin */
761const char *const *xine_post_list_inputs(xine_post_t *self) XINE_PROTECTED;
762
763/* get a list of all outputs of a post plugin */
764const char *const *xine_post_list_outputs(xine_post_t *self) XINE_PROTECTED;
765
766/* retrieve one specific input of a post plugin */
768
769/* retrieve one specific output of a post plugin */
771
772/*
773 * wire an input to an output
774 * returns 1 on success, 0 on failure
775 */
777
778/*
779 * wire a video port to a video output
780 * This can be used to rewire different post plugins to the video output
781 * plugin layer. The ports you hand in at xine_post_init() will already
782 * be wired with the post plugin, so you need this function for
783 * _re_connecting only.
784 *
785 * returns 1 on success, 0 on failure
786 */
788
789/*
790 * wire an audio port to an audio output
791 * This can be used to rewire different post plugins to the audio output
792 * plugin layer. The ports you hand in at xine_post_init() will already
793 * be wired with the post plugin, so you need this function for
794 * _re_connecting only.
795 *
796 * returns 1 on success, 0 on failure
797 */
799
800/*
801 * Extracts an output for a stream. Use this to rewire the outputs of streams.
802 */
805
806/*
807 * disposes the post plugin
808 * please make sure that no other post plugin and no stream is
809 * connected to any of this plugin's inputs
810 */
812
813
814/* post plugin types */
815#define XINE_POST_TYPE_VIDEO_FILTER 0x010000
816#define XINE_POST_TYPE_VIDEO_VISUALIZATION 0x010001
817#define XINE_POST_TYPE_VIDEO_COMPOSE 0x010002
818#define XINE_POST_TYPE_AUDIO_FILTER 0x020000
819#define XINE_POST_TYPE_AUDIO_VISUALIZATION 0x020001
820
821
822/* post plugin data types */
823
824/* video port data
825 * input->data is a xine_video_port_t*
826 * output->data usually is a xine_video_port_t**
827 */
828#define XINE_POST_DATA_VIDEO 0
829
830/* audio port data
831 * input->data is a xine_audio_port_t*
832 * output->data usually is a xine_audio_port_t**
833 */
834#define XINE_POST_DATA_AUDIO 1
835
836/* integer data
837 * input->data is a int*
838 * output->data usually is a int*
839 */
840#define XINE_POST_DATA_INT 3
841
842/* double precision floating point data
843 * input->data is a double*
844 * output->data usually is a double*
845 */
846#define XINE_POST_DATA_DOUBLE 4
847
848/* parameters api (used by frontends)
849 * input->data is xine_post_api_t* (see below)
850 */
851#define XINE_POST_DATA_PARAMETERS 5
852
853/* defines a single parameter entry. */
854typedef struct {
855 int type; /* POST_PARAM_TYPE_xxx */
856 const char *name; /* name of this parameter */
857 int size; /* sizeof(parameter) */
858 int offset; /* offset in bytes from struct ptr */
859 char **enum_values; /* enumeration (first=0) or NULL */
860 double range_min; /* minimum value */
861 double range_max; /* maximum value */
862 int readonly; /* 0 = read/write, 1=read-only */
863 const char *description; /* user-friendly description */
865
866/* description of parameters struct (params). */
867typedef struct {
868 int struct_size; /* sizeof(params) */
869 xine_post_api_parameter_t *parameter; /* list of parameters */
871
872typedef struct {
873 /*
874 * method to set all the read/write parameters.
875 * params is a struct * defined by xine_post_api_descr_t
876 */
877 int (*set_parameters) (xine_post_t *self, const void *params);
878
879 /*
880 * method to get all parameters.
881 */
882 int (*get_parameters) (xine_post_t *self, void *params);
883
884 /*
885 * method to get params struct definition
886 */
887 xine_post_api_descr_t * (*get_param_descr) (void);
888
889 /*
890 * method to get plugin and parameters help (UTF-8)
891 * the help string must be word wrapped by the frontend.
892 * it might contain \n to mark paragraph breaks.
893 */
894 char * (*get_help) (void);
896
897/* post parameter types */
898#define POST_PARAM_TYPE_LAST 0 /* terminator of parameter list */
899#define POST_PARAM_TYPE_INT 1 /* integer (or vector of integers) */
900#define POST_PARAM_TYPE_DOUBLE 2 /* double (or vector of doubles) */
901#define POST_PARAM_TYPE_CHAR 3 /* char (or vector of chars = string) */
902#define POST_PARAM_TYPE_STRING 4 /* (char *), ASCIIZ */
903#define POST_PARAM_TYPE_STRINGLIST 5 /* (char **) list, NULL terminated */
904#define POST_PARAM_TYPE_BOOL 6 /* integer (0 or 1) */
905
906
907/*********************************************************************
908 * information retrieval *
909 *********************************************************************/
910
911/*
912 * xine log functions
913 *
914 * frontends can display xine log output using these functions
915 */
917
918/* return a NULL terminated array of log sections names */
919const char *const *xine_get_log_names(xine_t *self) XINE_PROTECTED;
920
921/* print some log information to <buf> section */
922void xine_log (xine_t *self, int buf,
923 const char *format, ...) XINE_FORMAT_PRINTF(3, 4) XINE_PROTECTED;
924void xine_vlog(xine_t *self, int buf,
925 const char *format, va_list args) XINE_FORMAT_PRINTF(3, 0) XINE_PROTECTED;
926
927/* get log messages of specified section */
928char *const *xine_get_log (xine_t *self, int buf) XINE_PROTECTED;
929
930/* log callback will be called whenever something is logged */
931typedef void (*xine_log_cb_t) (void *user_data, int section);
934
935/*
936 * error handling / engine status
937 */
938
939/* return last error */
941
942/* get current xine engine status (constants see below) */
944
945/*
946 * engine status codes
947 */
948#define XINE_STATUS_IDLE 0 /* no mrl assigned */
949#define XINE_STATUS_STOP 1
950#define XINE_STATUS_PLAY 2
951#define XINE_STATUS_QUIT 3
952
953/*
954 * xine error codes
955 */
956#define XINE_ERROR_NONE 0
957#define XINE_ERROR_NO_INPUT_PLUGIN 1
958#define XINE_ERROR_NO_DEMUX_PLUGIN 2
959#define XINE_ERROR_DEMUX_FAILED 3
960#define XINE_ERROR_MALFORMED_MRL 4
961#define XINE_ERROR_INPUT_FAILED 5
962
963/*
964 * try to find out audio/spu language of given channel
965 * (use -1 for current channel)
966 *
967 * lang must point to a buffer of at least XINE_LANG_MAX bytes
968 *
969 * returns 1 on success, 0 on failure
970 */
971int xine_get_audio_lang (xine_stream_t *stream, int channel,
972 char *lang) XINE_PROTECTED;
973int xine_get_spu_lang (xine_stream_t *stream, int channel,
974 char *lang) XINE_PROTECTED;
975/*_x_ increasing this number means an incompatible ABI breakage! */
976#define XINE_LANG_MAX 32
977
978/*
979 * get position / length information
980 *
981 * depending of the nature and system layer of the stream,
982 * some or all of this information may be unavailable or incorrect
983 * (e.g. live network streams may not have a valid length)
984 *
985 * returns 1 on success, 0 on failure (data was not updated,
986 * probably because it's not known yet... try again later)
987 */
989 int *pos_stream, /* 0..65535 */
990 int *pos_time, /* milliseconds */
991 int *length_time) /* milliseconds */
993
994/*
995 * get information about the stream such as
996 * video width/height, codecs, audio format, title, author...
997 * strings are UTF-8 encoded.
998 *
999 * constants see below
1000 */
1001uint32_t xine_get_stream_info (xine_stream_t *stream, int info) XINE_PROTECTED;
1002const char *xine_get_meta_info (xine_stream_t *stream, int info) XINE_PROTECTED;
1003
1004/* xine_get_stream_info */
1005#define XINE_STREAM_INFO_BITRATE 0
1006#define XINE_STREAM_INFO_SEEKABLE 1
1007#define XINE_STREAM_INFO_VIDEO_WIDTH 2
1008#define XINE_STREAM_INFO_VIDEO_HEIGHT 3
1009#define XINE_STREAM_INFO_VIDEO_RATIO 4 /* *10000 */
1010#define XINE_STREAM_INFO_VIDEO_CHANNELS 5
1011#define XINE_STREAM_INFO_VIDEO_STREAMS 6
1012#define XINE_STREAM_INFO_VIDEO_BITRATE 7
1013#define XINE_STREAM_INFO_VIDEO_FOURCC 8
1014#define XINE_STREAM_INFO_VIDEO_HANDLED 9 /* codec available? */
1015#define XINE_STREAM_INFO_FRAME_DURATION 10 /* 1/90000 sec */
1016#define XINE_STREAM_INFO_AUDIO_CHANNELS 11
1017#define XINE_STREAM_INFO_AUDIO_BITS 12
1018#define XINE_STREAM_INFO_AUDIO_SAMPLERATE 13
1019#define XINE_STREAM_INFO_AUDIO_BITRATE 14
1020#define XINE_STREAM_INFO_AUDIO_FOURCC 15
1021#define XINE_STREAM_INFO_AUDIO_HANDLED 16 /* codec available? */
1022#define XINE_STREAM_INFO_HAS_CHAPTERS 17
1023#define XINE_STREAM_INFO_HAS_VIDEO 18
1024#define XINE_STREAM_INFO_HAS_AUDIO 19
1025#define XINE_STREAM_INFO_IGNORE_VIDEO 20
1026#define XINE_STREAM_INFO_IGNORE_AUDIO 21
1027#define XINE_STREAM_INFO_IGNORE_SPU 22
1028#define XINE_STREAM_INFO_VIDEO_HAS_STILL 23
1029#define XINE_STREAM_INFO_MAX_AUDIO_CHANNEL 24
1030#define XINE_STREAM_INFO_MAX_SPU_CHANNEL 25
1031#define XINE_STREAM_INFO_AUDIO_MODE 26
1032#define XINE_STREAM_INFO_SKIPPED_FRAMES 27 /* for 1000 frames delivered */
1033#define XINE_STREAM_INFO_DISCARDED_FRAMES 28 /* for 1000 frames delivered */
1034#define XINE_STREAM_INFO_VIDEO_AFD 29
1035#define XINE_STREAM_INFO_DVD_TITLE_NUMBER 30
1036#define XINE_STREAM_INFO_DVD_TITLE_COUNT 31
1037#define XINE_STREAM_INFO_DVD_CHAPTER_NUMBER 32
1038#define XINE_STREAM_INFO_DVD_CHAPTER_COUNT 33
1039#define XINE_STREAM_INFO_DVD_ANGLE_NUMBER 34
1040#define XINE_STREAM_INFO_DVD_ANGLE_COUNT 35
1041
1042/* possible values for XINE_STREAM_INFO_VIDEO_AFD */
1043#define XINE_VIDEO_AFD_NOT_PRESENT -1
1044#define XINE_VIDEO_AFD_RESERVED_0 0
1045#define XINE_VIDEO_AFD_RESERVED_1 1
1046#define XINE_VIDEO_AFD_BOX_16_9_TOP 2
1047#define XINE_VIDEO_AFD_BOX_14_9_TOP 3
1048#define XINE_VIDEO_AFD_BOX_GT_16_9_CENTRE 4
1049#define XINE_VIDEO_AFD_RESERVED_5 5
1050#define XINE_VIDEO_AFD_RESERVED_6 6
1051#define XINE_VIDEO_AFD_RESERVED_7 7
1052#define XINE_VIDEO_AFD_SAME_AS_FRAME 8
1053#define XINE_VIDEO_AFD_4_3_CENTRE 9
1054#define XINE_VIDEO_AFD_16_9_CENTRE 10
1055#define XINE_VIDEO_AFD_14_9_CENTRE 11
1056#define XINE_VIDEO_AFD_RESERVED_12 12
1057#define XINE_VIDEO_AFD_4_3_PROTECT_14_9 13
1058#define XINE_VIDEO_AFD_16_9_PROTECT_14_9 14
1059#define XINE_VIDEO_AFD_16_9_PROTECT_4_3 15
1060
1061/* xine_get_meta_info */
1062#define XINE_META_INFO_TITLE 0
1063#define XINE_META_INFO_COMMENT 1
1064#define XINE_META_INFO_ARTIST 2
1065#define XINE_META_INFO_GENRE 3
1066#define XINE_META_INFO_ALBUM 4
1067#define XINE_META_INFO_YEAR 5 /* may be full date */
1068#define XINE_META_INFO_VIDEOCODEC 6
1069#define XINE_META_INFO_AUDIOCODEC 7
1070#define XINE_META_INFO_SYSTEMLAYER 8
1071#define XINE_META_INFO_INPUT_PLUGIN 9
1072#define XINE_META_INFO_CDINDEX_DISCID 10
1073#define XINE_META_INFO_TRACK_NUMBER 11
1074#define XINE_META_INFO_COMPOSER 12
1075/* post-1.1.17; taken from the list at http://age.hobba.nl/audio/mirroredpages/ogg-tagging.html on 2009-12-11 */
1076#define XINE_META_INFO_PUBLISHER 13
1077#define XINE_META_INFO_COPYRIGHT 14
1078#define XINE_META_INFO_LICENSE 15
1079#define XINE_META_INFO_ARRANGER 16
1080#define XINE_META_INFO_LYRICIST 17
1081#define XINE_META_INFO_AUTHOR 18
1082#define XINE_META_INFO_CONDUCTOR 19
1083#define XINE_META_INFO_PERFORMER 20
1084#define XINE_META_INFO_ENSEMBLE 21
1085#define XINE_META_INFO_OPUS 22
1086#define XINE_META_INFO_PART 23
1087#define XINE_META_INFO_PARTNUMBER 24
1088#define XINE_META_INFO_LOCATION 25
1089/* post-1.1.18.1 */
1090#define XINE_META_INFO_DISCNUMBER 26
1091
1092
1093/*********************************************************************
1094 * plugin management / autoplay / mrl browsing *
1095 *********************************************************************/
1096
1097/*
1098 * note: the pointers to strings or string arrays returned
1099 * by some of these functions are pointers to statically
1100 * alloced internal xine memory chunks.
1101 * they're only valid between xine function calls
1102 * and should never be free()d.
1103 */
1104
1105typedef struct xine_mrl_s xine_mrl_t;
1106
1108 char *origin; /* file plugin: path */
1109 char *mrl; /* <type>://<location> */
1110 char *link;
1111 off_t size; /* size of this source, may be 0 */
1112 uint32_t type; /* see below */
1113};
1114
1115/* mrl types */
1116#define XINE_MRL_TYPE_unknown (0 << 0)
1117#define XINE_MRL_TYPE_dvd (1 << 0)
1118#define XINE_MRL_TYPE_vcd (1 << 1)
1119#define XINE_MRL_TYPE_net (1 << 2)
1120#define XINE_MRL_TYPE_rtp (1 << 3)
1121#define XINE_MRL_TYPE_stdin (1 << 4)
1122#define XINE_MRL_TYPE_cda (1 << 5)
1123#define XINE_MRL_TYPE_file (1 << 6)
1124#define XINE_MRL_TYPE_file_fifo (1 << 7)
1125#define XINE_MRL_TYPE_file_chardev (1 << 8)
1126#define XINE_MRL_TYPE_file_directory (1 << 9)
1127#define XINE_MRL_TYPE_file_blockdev (1 << 10)
1128#define XINE_MRL_TYPE_file_normal (1 << 11)
1129#define XINE_MRL_TYPE_file_symlink (1 << 12)
1130#define XINE_MRL_TYPE_file_sock (1 << 13)
1131#define XINE_MRL_TYPE_file_exec (1 << 14)
1132#define XINE_MRL_TYPE_file_backup (1 << 15)
1133#define XINE_MRL_TYPE_file_hidden (1 << 16)
1134
1135/* get a list of browsable input plugin ids */
1137
1138/*
1139 * ask input plugin named <plugin_id> to return
1140 * a list of available MRLs in domain/directory <start_mrl>.
1141 *
1142 * <start_mrl> may be NULL indicating the toplevel domain/dir
1143 * returns <start_mrl> if <start_mrl> is a valid MRL, not a directory
1144 * returns NULL if <start_mrl> is an invalid MRL, not even a directory.
1145 */
1147 const char *plugin_id,
1148 const char *start_mrl,
1149 int *num_mrls) XINE_PROTECTED;
1150
1151/* get a list of plugins that support the autoplay feature */
1153
1154/* get autoplay MRL list from input plugin named <plugin_id> */
1155const char * const *xine_get_autoplay_mrls (xine_t *self,
1156 const char *plugin_id,
1157 int *num_mrls) XINE_PROTECTED;
1158
1159/* get a list of file extensions for file types supported by xine
1160 * the list is separated by spaces
1161 *
1162 * the pointer returned can be free()ed when no longer used */
1164
1165/* get a list of mime types supported by xine
1166 *
1167 * the pointer returned can be free()ed when no longer used */
1169
1170/* get the demuxer identifier that handles a given mime type
1171 *
1172 * the pointer returned can be free()ed when no longer used
1173 * returns NULL if no demuxer is available to handle this. */
1174char *xine_get_demux_for_mime_type (xine_t *self, const char *mime_type) XINE_PROTECTED;
1175
1176/* get a description string for a plugin */
1177const char *xine_get_input_plugin_description (xine_t *self,
1178 const char *plugin_id) XINE_PROTECTED;
1179const char *xine_get_demux_plugin_description (xine_t *self,
1180 const char *plugin_id) XINE_PROTECTED;
1181const char *xine_get_spu_plugin_description (xine_t *self,
1182 const char *plugin_id) XINE_PROTECTED;
1183const char *xine_get_audio_plugin_description (xine_t *self,
1184 const char *plugin_id) XINE_PROTECTED;
1185const char *xine_get_video_plugin_description (xine_t *self,
1186 const char *plugin_id) XINE_PROTECTED;
1188 const char *plugin_id) XINE_PROTECTED;
1190 const char *plugin_id) XINE_PROTECTED;
1191const char *xine_get_post_plugin_description (xine_t *self,
1192 const char *plugin_id) XINE_PROTECTED;
1193
1194/* get lists of available audio and video output plugins */
1195const char *const *xine_list_audio_output_plugins (xine_t *self) XINE_PROTECTED;
1196const char *const *xine_list_video_output_plugins (xine_t *self) XINE_PROTECTED;
1197/* typemask is (1ULL << XINE_VISUAL_TYPE_FOO) | ... */
1198const char *const *xine_list_video_output_plugins_typed (xine_t *self, uint64_t typemask) XINE_PROTECTED;
1199
1200/* get list of available demultiplexor plugins */
1201const char *const *xine_list_demuxer_plugins(xine_t *self) XINE_PROTECTED;
1202
1203/* get list of available input plugins */
1204const char *const *xine_list_input_plugins(xine_t *self) XINE_PROTECTED;
1205
1206/* get list of available subpicture plugins */
1207const char *const *xine_list_spu_plugins(xine_t *self) XINE_PROTECTED;
1208
1209/* get list of available audio and video decoder plugins */
1210const char *const *xine_list_audio_decoder_plugins(xine_t *self) XINE_PROTECTED;
1211const char *const *xine_list_video_decoder_plugins(xine_t *self) XINE_PROTECTED;
1212
1213/* unload unused plugins */
1215
1216
1217/*********************************************************************
1218 * visual specific gui <-> xine engine communication *
1219 *********************************************************************/
1220
1221/* new (preferred) method to talk to video driver. */
1223 int type, void *data) XINE_PROTECTED;
1224
1225typedef struct {
1226
1227 /* area of that drawable to be used by video */
1228 int x,y,w,h;
1229
1231
1232/*
1233 * this is the visual data struct any x11 gui
1234 * must supply to the xine_open_video_driver call
1235 * ("data" parameter)
1236 */
1237typedef struct {
1238
1239 /* some information about the display */
1240 void *display; /* Display* */
1242
1243 /* drawable to display the video in/on */
1244 unsigned long d; /* Drawable */
1245
1247
1248 /*
1249 * dest size callback
1250 *
1251 * this will be called by the video driver to find out
1252 * how big the video output area size will be for a
1253 * given video size. The ui should _not_ adjust its
1254 * video out area, just do some calculations and return
1255 * the size. This will be called for every frame, ui
1256 * implementation should be fast.
1257 * dest_pixel_aspect should be set to the used display pixel aspect.
1258 * NOTE: Semantics has changed: video_width and video_height
1259 * are no longer pixel aspect corrected. Get the old semantics
1260 * in the UI with
1261 * *dest_pixel_aspect = display_pixel_aspect;
1262 * if (video_pixel_aspect >= display_pixel_aspect)
1263 * video_width = video_width * video_pixel_aspect / display_pixel_aspect + .5;
1264 * else
1265 * video_height = video_height * display_pixel_aspect / video_pixel_aspect + .5;
1266 */
1267 void (*dest_size_cb) (void *user_data,
1268 int video_width, int video_height,
1269 double video_pixel_aspect,
1270 int *dest_width, int *dest_height,
1271 double *dest_pixel_aspect);
1272
1273 /*
1274 * frame output callback
1275 *
1276 * this will be called by the video driver for every frame
1277 * it's about to draw. ui can adapt its size if necessary
1278 * here.
1279 * note: the ui doesn't have to adjust itself to this
1280 * size, this is just to be taken as a hint.
1281 * ui must return the actual size of the video output
1282 * area and the video output driver will do its best
1283 * to adjust the video frames to that size (while
1284 * preserving aspect ratio and stuff).
1285 * dest_x, dest_y: offset inside window
1286 * dest_width, dest_height: available drawing space
1287 * dest_pixel_aspect: display pixel aspect
1288 * win_x, win_y: window absolute screen position
1289 * NOTE: Semantics has changed: video_width and video_height
1290 * are no longer pixel aspect corrected. Get the old semantics
1291 * in the UI with
1292 * *dest_pixel_aspect = display_pixel_aspect;
1293 * if (video_pixel_aspect >= display_pixel_aspect)
1294 * video_width = video_width * video_pixel_aspect / display_pixel_aspect + .5;
1295 * else
1296 * video_height = video_height * display_pixel_aspect / video_pixel_aspect + .5;
1297 */
1298 void (*frame_output_cb) (void *user_data,
1299 int video_width, int video_height,
1300 double video_pixel_aspect,
1301 int *dest_x, int *dest_y,
1302 int *dest_width, int *dest_height,
1303 double *dest_pixel_aspect,
1304 int *win_x, int *win_y);
1305
1306 /*
1307 * lock display callback
1308 *
1309 * this callback is called when the video driver
1310 * needs access to the x11 display connection
1311 *
1312 * note: to enable this you MUST use XINE_VISUAL_TYPE_X11_2
1313 * note: if display_lock is NULL, the fallback is used
1314 * note: fallback for this function is XLockDisplay(display)
1315 */
1316 void (*lock_display) (void *user_data);
1317
1318 /*
1319 * unlock display callback
1320 *
1321 * this callback is called when the video driver
1322 * doesn't need access to the x11 display connection anymore
1323 *
1324 * note: to enable this you MUST use XINE_VISUAL_TYPE_X11_2
1325 * note: if display_unlock is NULL, the fallback is used
1326 * note: fallback for this function is XUnlockDisplay(display)
1327 */
1328 void (*unlock_display) (void *user_data);
1329
1330} x11_visual_t;
1331
1332/*
1333 * this is the visual data struct any xcb gui
1334 * must supply to the xine_open_video_driver call
1335 * ("data" parameter)
1336 */
1337typedef struct {
1338
1339 /* some information about the display */
1340 void *connection; /* xcb_connection_t */
1341 void *screen; /* xcb_screen_t */
1342
1343 /* window to display the video in / on */
1344 unsigned int window; /* xcb_window_t */
1345
1347
1348 /*
1349 * dest size callback
1350 *
1351 * this will be called by the video driver to find out
1352 * how big the video output area size will be for a
1353 * given video size. The ui should _not_ adjust its
1354 * video out area, just do some calculations and return
1355 * the size. This will be called for every frame, ui
1356 * implementation should be fast.
1357 * dest_pixel_aspect should be set to the used display pixel aspect.
1358 * NOTE: Semantics has changed: video_width and video_height
1359 * are no longer pixel aspect corrected. Get the old semantics
1360 * in the UI with
1361 * *dest_pixel_aspect = display_pixel_aspect;
1362 * if (video_pixel_aspect >= display_pixel_aspect)
1363 * video_width = video_width * video_pixel_aspect / display_pixel_aspect + .5;
1364 * else
1365 * video_height = video_height * display_pixel_aspect / video_pixel_aspect + .5;
1366 */
1367 void (*dest_size_cb) (void *user_data,
1368 int video_width, int video_height,
1369 double video_pixel_aspect,
1370 int *dest_width, int *dest_height,
1371 double *dest_pixel_aspect);
1372
1373 /*
1374 * frame output callback
1375 *
1376 * this will be called by the video driver for every frame
1377 * it's about to draw. ui can adapt its size if necessary
1378 * here.
1379 * note: the ui doesn't have to adjust itself to this
1380 * size, this is just to be taken as a hint.
1381 * ui must return the actual size of the video output
1382 * area and the video output driver will do its best
1383 * to adjust the video frames to that size (while
1384 * preserving aspect ratio and stuff).
1385 * dest_x, dest_y: offset inside window
1386 * dest_width, dest_height: available drawing space
1387 * dest_pixel_aspect: display pixel aspect
1388 * win_x, win_y: window absolute screen position
1389 * NOTE: Semantics has changed: video_width and video_height
1390 * are no longer pixel aspect corrected. Get the old semantics
1391 * in the UI with
1392 * *dest_pixel_aspect = display_pixel_aspect;
1393 * if (video_pixel_aspect >= display_pixel_aspect)
1394 * video_width = video_width * video_pixel_aspect / display_pixel_aspect + .5;
1395 * else
1396 * video_height = video_height * display_pixel_aspect / video_pixel_aspect + .5;
1397 */
1398 void (*frame_output_cb) (void *user_data,
1399 int video_width, int video_height,
1400 double video_pixel_aspect,
1401 int *dest_x, int *dest_y,
1402 int *dest_width, int *dest_height,
1403 double *dest_pixel_aspect,
1404 int *win_x, int *win_y);
1405
1406} xcb_visual_t;
1407
1408/*
1409 * this is the visual data struct any Wayland GUI
1410 * must supply to the xine_open_video_driver call
1411 * ("data" parameter)
1412 */
1413
1414struct wl_display;
1415struct wl_surface;
1416
1417typedef struct {
1418
1419 struct wl_display *display;
1420 struct wl_surface *surface;
1421
1423 void (*frame_output_cb) (void *user_data,
1424 int video_width, int video_height,
1425 double video_pixel_aspect,
1426 int *dest_x, int *dest_y,
1427 int *dest_width, int *dest_height,
1428 double *dest_pixel_aspect,
1429 int *win_x, int *win_y);
1430
1432
1433/**************************************************
1434 * XINE_VO_RAW struct definitions
1435 *************************************************/
1436/* frame_format definitions */
1437#define XINE_VORAW_YV12 1
1438#define XINE_VORAW_YUY2 2
1439#define XINE_VORAW_RGB 4
1440
1441/* maximum number of overlays the raw driver can handle */
1442#define XINE_VORAW_MAX_OVL 16
1443
1444/* raw_overlay_t struct used in raw_overlay_cb callback */
1445typedef struct {
1446 uint8_t *ovl_rgba;
1447 int ovl_w, ovl_h; /* overlay's width and height */
1448 int ovl_x, ovl_y; /* overlay's top-left display position */
1450
1451/* this is the visual data struct any raw gui
1452 * must supply to the xine_open_video_driver call
1453 * ("data" parameter)
1454 */
1455typedef struct {
1457
1458 /* OR'ed frame_format
1459 * Unsupported frame formats are converted to rgb.
1460 * XINE_VORAW_RGB is always assumed by the driver, even if not set.
1461 * So a frontend must at least support rgb.
1462 * Be aware that rgb requires more cpu than yuv,
1463 * so avoid its usage for video playback.
1464 * However, it's useful for single frame capture (e.g. thumbs)
1465 */
1467
1468 /* raw output callback
1469 * this will be called by the video driver for every frame
1470 *
1471 * If frame_format==XINE_VORAW_YV12, data0 points to frame_width*frame_height Y values
1472 * data1 points to (frame_width/2)*(frame_height/2) U values
1473 * data2 points to (frame_width/2)*(frame_height/2) V values
1474 *
1475 * If frame_format==XINE_VORAW_YUY2, data0 points to frame_width*frame_height*2 YU/Y²V values
1476 * data1 is NULL
1477 * data2 is NULL
1478 *
1479 * If frame_format==XINE_VORAW_RGB, data0 points to frame_width*frame_height*3 RGB values
1480 * data1 is NULL
1481 * data2 is NULL
1482 */
1483 void (*raw_output_cb) (void *user_data, int frame_format,
1484 int frame_width, int frame_height,
1485 double frame_aspect,
1486 void *data0, void *data1, void *data2);
1487
1488 /* raw overlay callback
1489 * this will be called by the video driver for every new overlay state
1490 * overlays_array points to an array of num_ovl raw_overlay_t
1491 * Note that num_ovl can be 0, meaning "end of overlay display"
1492 * num_ovl is at most XINE_VORAW_MAX_OVL */
1493 void (*raw_overlay_cb) (void *user_data, int num_ovl,
1494 raw_overlay_t *overlays_array);
1495} raw_visual_t;
1496/**********************************************
1497 * end of vo_raw defs
1498 *********************************************/
1499
1500/*
1501 * this is the visual data struct any fb gui
1502 * may supply to the xine_open_video_driver call
1503 * ("data" parameter) to get frame_output_cd calls
1504 */
1505
1506typedef struct {
1507
1508 void (*frame_output_cb) (void *user_data,
1509 int video_width, int video_height,
1510 double video_pixel_aspect,
1511 int *dest_x, int *dest_y,
1512 int *dest_width, int *dest_height,
1513 double *dest_pixel_aspect,
1514 int *win_x, int *win_y);
1515
1517
1518} fb_visual_t;
1519
1520#if defined(WIN32) && (!defined(XINE_COMPILE) || defined(XINE_NEED_WIN32_VISUAL))
1521/*
1522 * this is the visual data struct any win32 gui should supply
1523 * (pass this to init_video_out_plugin or the xine_load_video_output_plugin
1524 * utility function)
1525 */
1526
1527typedef struct {
1528
1529 HWND WndHnd; /* handle of window associated with primary surface */
1530 HINSTANCE HInst; /* handle of windows application instance */
1531 RECT WndRect; /* rect of window client points translated to screen
1532 * cooridnates */
1533 int FullScreen; /* is window fullscreen */
1534 HBRUSH Brush; /* window brush for background color */
1535 COLORREF ColorKey; /* window brush color key */
1536
1537} win32_visual_t;
1538
1539/*
1540 * constants for gui_data_exchange's data_type parameter
1541 */
1542
1543#define GUI_WIN32_MOVED_OR_RESIZED 0
1544
1545#endif /* WIN32 */
1546
1547/*
1548 * "type" constants for xine_port_send_gui_data(...)
1549 */
1550
1551#ifndef XINE_DISABLE_DEPRECATED_FEATURES
1552/* xevent *data */
1553#define XINE_GUI_SEND_COMPLETION_EVENT 1 /* DEPRECATED */
1554#endif
1555
1556/* Drawable data */
1557#define XINE_GUI_SEND_DRAWABLE_CHANGED 2
1558
1559/* xevent *data */
1560#define XINE_GUI_SEND_EXPOSE_EVENT 3
1561
1562/* x11_rectangle_t *data */
1563#define XINE_GUI_SEND_TRANSLATE_GUI_TO_VIDEO 4
1564
1565/* int data */
1566#define XINE_GUI_SEND_VIDEOWIN_VISIBLE 5
1567
1568/* *data contains chosen visual, select a new one or change it to NULL
1569 * to indicate the visual to use or that no visual will work */
1570/* XVisualInfo **data */
1571#define XINE_GUI_SEND_SELECT_VISUAL 8
1572
1573/* Gui is about to destroy drawable */
1574#define XINE_GUI_SEND_WILL_DESTROY_DRAWABLE 9
1575
1576
1577/*********************************************************************
1578 * xine health check stuff *
1579 *********************************************************************/
1580
1581#define XINE_HEALTH_CHECK_OK 0
1582#define XINE_HEALTH_CHECK_FAIL 1
1583#define XINE_HEALTH_CHECK_UNSUPPORTED 2
1584#define XINE_HEALTH_CHECK_NO_SUCH_CHECK 3
1585
1586#define CHECK_KERNEL 0
1587#define CHECK_MTRR 1
1588#define CHECK_CDROM 2
1589#define CHECK_DVDROM 3
1590#define CHECK_DMA 4
1591#define CHECK_X 5
1592#define CHECK_XV 6
1593
1595 const char* cdrom_dev;
1596 const char* dvd_dev;
1597 const char* msg;
1598 const char* title;
1599 const char* explanation;
1601};
1602
1605
1606
1607/*********************************************************************
1608 * configuration system *
1609 *********************************************************************/
1610
1611/*
1612 * config entry data types
1613 */
1614
1615#define XINE_CONFIG_TYPE_UNKNOWN 0
1616#define XINE_CONFIG_TYPE_RANGE 1
1617#define XINE_CONFIG_TYPE_STRING 2
1618#define XINE_CONFIG_TYPE_ENUM 3
1619#define XINE_CONFIG_TYPE_NUM 4
1620#define XINE_CONFIG_TYPE_BOOL 5
1621
1622/* For the string type (1.1.4 and later). These are stored in num_value. */
1623#define XINE_CONFIG_STRING_IS_STRING 0
1624#define XINE_CONFIG_STRING_IS_FILENAME 1
1625#define XINE_CONFIG_STRING_IS_DEVICE_NAME 2
1626#define XINE_CONFIG_STRING_IS_DIRECTORY_NAME 3
1627
1629
1630typedef void (*xine_config_cb_t) (void *user_data,
1631 xine_cfg_entry_t *entry);
1633 const char *key; /* unique id (example: gui.logo_mrl) */
1634
1635 int type;
1636
1637 /* user experience level */
1638 int exp_level; /* 0 => beginner,
1639 10 => advanced user,
1640 20 => expert */
1641
1642 /* type unknown */
1644
1645 /* type string */
1648
1649 /* common to range, enum, num, bool;
1650 * num_value is also used by string to indicate what's required:
1651 * plain string, file name, device name, directory name
1652 */
1655
1656 /* type range specific: */
1659
1660 /* type enum specific: */
1662
1663 /* help info for the user (UTF-8)
1664 * the help string must be word wrapped by the frontend.
1665 * it might contain \n to mark paragraph breaks.
1666 */
1667 const char *description;
1668 const char *help;
1669
1670 /* callback function and data for live changeable values */
1671 /* some config entries will take effect immediately, although they
1672 * do not have a callback registered; such values will have some
1673 * non-NULL dummy value in callback_data; so if you want to check,
1674 * if a config change will require restarting xine, check for
1675 * callback_data == NULL */
1678
1679};
1680
1681const char *xine_config_register_string (xine_t *self,
1682 const char *key,
1683 const char *def_value,
1684 const char *description,
1685 const char *help,
1686 int exp_level,
1687 xine_config_cb_t changed_cb,
1688 void *cb_data) XINE_PROTECTED;
1689
1690const char *xine_config_register_filename (xine_t *self,
1691 const char *key,
1692 const char *def_value,
1693 int req_type, /* XINE_CONFIG_STRING_IS_* */
1694 const char *description,
1695 const char *help,
1696 int exp_level,
1697 xine_config_cb_t changed_cb,
1698 void *cb_data) XINE_PROTECTED;
1699
1701 const char *key,
1702 int def_value,
1703 int min, int max,
1704 const char *description,
1705 const char *help,
1706 int exp_level,
1707 xine_config_cb_t changed_cb,
1708 void *cb_data) XINE_PROTECTED;
1709
1711 const char *key,
1712 int def_value,
1713 char **values,
1714 const char *description,
1715 const char *help,
1716 int exp_level,
1717 xine_config_cb_t changed_cb,
1718 void *cb_data) XINE_PROTECTED;
1719
1721 const char *key,
1722 int def_value,
1723 const char *description,
1724 const char *help,
1725 int exp_level,
1726 xine_config_cb_t changed_cb,
1727 void *cb_data) XINE_PROTECTED;
1728
1730 const char *key,
1731 int def_value,
1732 const char *description,
1733 const char *help,
1734 int exp_level,
1735 xine_config_cb_t changed_cb,
1736 void *cb_data) XINE_PROTECTED;
1737
1745#define HAVE_XINE_CONFIG_UNREGISTER_CALLBACKS 1
1747 const char *key, xine_config_cb_t changed_cb, void *cb_data, size_t cb_data_size) XINE_PROTECTED;
1748
1749/*
1750 * the following functions will copy data from the internal xine_config
1751 * data database to the xine_cfg_entry_t *entry you provide
1752 *
1753 * they return 1 on success, 0 on failure
1754 */
1755
1756/* get first config item */
1758
1759/* get next config item (iterate through the items) */
1761
1762/* search for a config entry by key */
1763int xine_config_lookup_entry (xine_t *self, const char *key,
1765
1766/*
1767 * Helper function to get numeric value of config entry.
1768 * Return def_value if entry was not found (or is not correct type).
1769 */
1770int xine_config_lookup_num(xine_t *self, const char *key, int def_value) XINE_PROTECTED;
1771
1772/*
1773 * Thread-safe helper function to get string value of config entry.
1774 * Return copy of current value or NULL.
1775 * Returned string must be freed with xine_config_free_str().
1776 */
1777char *xine_config_lookup_string(xine_t *self, const char *key) XINE_PROTECTED;
1778void xine_config_free_string(xine_t *self, char **value) XINE_PROTECTED;
1779
1780/*
1781 * update a config entry (which was returned from lookup_entry() )
1782 *
1783 * xine will make a deep copy of the data in the entry into its internal
1784 * config database.
1785 */
1787 const xine_cfg_entry_t *entry) XINE_PROTECTED;
1788
1789/*
1790 * translation of old configuration entry names
1791 */
1792typedef struct {
1793 const char *old_name, *new_name;
1795
1797
1798/*
1799 * load/save config data from/to afile (e.g. $HOME/.xine/config)
1800 */
1801void xine_config_load (xine_t *self, const char *cfg_filename) XINE_PROTECTED;
1802void xine_config_save (xine_t *self, const char *cfg_filename) XINE_PROTECTED;
1804
1805
1806/*********************************************************************
1807 * asynchroneous xine event mechanism *
1808 *********************************************************************/
1809
1810/*
1811 * to receive events you have to register an event queue with
1812 * the xine engine (xine_event_new_queue, see below).
1813 *
1814 * then you can either
1815 * 1) check for incoming events regularly (xine_event_get/wait),
1816 * process them and free them using xine_event_free
1817 * 2) use xine_event_create_listener_thread and specify a callback
1818 * which will then be called for each event
1819 *
1820 * to send events to every module listening you don't need
1821 * to register an event queue but simply call xine_event_send.
1822 *
1823 * front ends should listen for one of MRL_REFERENCE and MRL_REFERENCE_EXT
1824 * since both will be sent for compatibility reasons
1825 */
1826
1827/* event types */
1828#define XINE_EVENT_UI_PLAYBACK_FINISHED 1 /* frontend can e.g. move on to next playlist entry */
1829#define XINE_EVENT_UI_CHANNELS_CHANGED 2 /* inform ui that new channel info is available */
1830#define XINE_EVENT_UI_SET_TITLE 3 /* request title display change in ui */
1831#define XINE_EVENT_UI_MESSAGE 4 /* message (dialog) for the ui to display */
1832#define XINE_EVENT_FRAME_FORMAT_CHANGE 5 /* e.g. aspect ratio change during dvd playback */
1833#define XINE_EVENT_AUDIO_LEVEL 6 /* report current audio level (l/r/mute) */
1834#define XINE_EVENT_QUIT 7 /* last event sent when stream is disposed */
1835#define XINE_EVENT_PROGRESS 8 /* index creation/network connections */
1836#define XINE_EVENT_MRL_REFERENCE 9 /* (deprecated) demuxer->frontend: MRL reference(s) for the real stream */
1837#define XINE_EVENT_UI_NUM_BUTTONS 10 /* number of buttons for interactive menus */
1838#define XINE_EVENT_SPU_BUTTON 11 /* the mouse pointer enter/leave a button */
1839#define XINE_EVENT_DROPPED_FRAMES 12 /* number of dropped frames is too high */
1840#define XINE_EVENT_MRL_REFERENCE_EXT 13 /* demuxer->frontend: MRL reference(s) for the real stream */
1841#define XINE_EVENT_AUDIO_AMP_LEVEL 14 /* report current audio amp level (l/r/mute) */
1842#define XINE_EVENT_NBC_STATS 15 /* nbc buffer status */
1843
1844
1845/* input events coming from frontend */
1846#define XINE_EVENT_INPUT_MOUSE_BUTTON 101
1847#define XINE_EVENT_INPUT_MOUSE_MOVE 102
1848#define XINE_EVENT_INPUT_MENU1 103
1849#define XINE_EVENT_INPUT_MENU2 104
1850#define XINE_EVENT_INPUT_MENU3 105
1851#define XINE_EVENT_INPUT_MENU4 106
1852#define XINE_EVENT_INPUT_MENU5 107
1853#define XINE_EVENT_INPUT_MENU6 108
1854#define XINE_EVENT_INPUT_MENU7 109
1855#define XINE_EVENT_INPUT_UP 110
1856#define XINE_EVENT_INPUT_DOWN 111
1857#define XINE_EVENT_INPUT_LEFT 112
1858#define XINE_EVENT_INPUT_RIGHT 113
1859#define XINE_EVENT_INPUT_SELECT 114
1860#define XINE_EVENT_INPUT_NEXT 115
1861#define XINE_EVENT_INPUT_PREVIOUS 116
1862#define XINE_EVENT_INPUT_ANGLE_NEXT 117
1863#define XINE_EVENT_INPUT_ANGLE_PREVIOUS 118
1864#define XINE_EVENT_INPUT_BUTTON_FORCE 119
1865#define XINE_EVENT_INPUT_NUMBER_0 120
1866#define XINE_EVENT_INPUT_NUMBER_1 121
1867#define XINE_EVENT_INPUT_NUMBER_2 122
1868#define XINE_EVENT_INPUT_NUMBER_3 123
1869#define XINE_EVENT_INPUT_NUMBER_4 124
1870#define XINE_EVENT_INPUT_NUMBER_5 125
1871#define XINE_EVENT_INPUT_NUMBER_6 126
1872#define XINE_EVENT_INPUT_NUMBER_7 127
1873#define XINE_EVENT_INPUT_NUMBER_8 128
1874#define XINE_EVENT_INPUT_NUMBER_9 129
1875#define XINE_EVENT_INPUT_NUMBER_10_ADD 130
1876
1877/* specific event types */
1878#define XINE_EVENT_SET_V4L2 200
1879#define XINE_EVENT_PVR_SAVE 201
1880#define XINE_EVENT_PVR_REPORT_NAME 202
1881#define XINE_EVENT_PVR_REALTIME 203
1882#define XINE_EVENT_PVR_PAUSE 204
1883#define XINE_EVENT_SET_MPEG_DATA 205
1884
1885/* VDR specific event types */
1886#define XINE_EVENT_VDR_RED 300
1887#define XINE_EVENT_VDR_GREEN 301
1888#define XINE_EVENT_VDR_YELLOW 302
1889#define XINE_EVENT_VDR_BLUE 303
1890#define XINE_EVENT_VDR_PLAY 304
1891#define XINE_EVENT_VDR_PAUSE 305
1892#define XINE_EVENT_VDR_STOP 306
1893#define XINE_EVENT_VDR_RECORD 307
1894#define XINE_EVENT_VDR_FASTFWD 308
1895#define XINE_EVENT_VDR_FASTREW 309
1896#define XINE_EVENT_VDR_POWER 310
1897#define XINE_EVENT_VDR_CHANNELPLUS 311
1898#define XINE_EVENT_VDR_CHANNELMINUS 312
1899#define XINE_EVENT_VDR_SCHEDULE 313
1900#define XINE_EVENT_VDR_CHANNELS 314
1901#define XINE_EVENT_VDR_TIMERS 315
1902#define XINE_EVENT_VDR_RECORDINGS 316
1903#define XINE_EVENT_VDR_SETUP 317
1904#define XINE_EVENT_VDR_COMMANDS 318
1905#define XINE_EVENT_VDR_BACK 319
1906#define XINE_EVENT_VDR_USER1 320
1907#define XINE_EVENT_VDR_USER2 321
1908#define XINE_EVENT_VDR_USER3 322
1909#define XINE_EVENT_VDR_USER4 323
1910#define XINE_EVENT_VDR_USER5 324
1911#define XINE_EVENT_VDR_USER6 325
1912#define XINE_EVENT_VDR_USER7 326
1913#define XINE_EVENT_VDR_USER8 327
1914#define XINE_EVENT_VDR_USER9 328
1915#define XINE_EVENT_VDR_VOLPLUS 329
1916#define XINE_EVENT_VDR_VOLMINUS 330
1917#define XINE_EVENT_VDR_MUTE 331
1918#define XINE_EVENT_VDR_AUDIO 332
1919#define XINE_EVENT_VDR_INFO 333
1920#define XINE_EVENT_VDR_CHANNELPREVIOUS 334
1921#define XINE_EVENT_VDR_SUBTITLES 335
1922#define XINE_EVENT_VDR_USER0 336
1923/* some space for further keys */
1924#define XINE_EVENT_VDR_SETVIDEOWINDOW 350
1925#define XINE_EVENT_VDR_FRAMESIZECHANGED 351
1926#define XINE_EVENT_VDR_SELECTAUDIO 352
1927#define XINE_EVENT_VDR_TRICKSPEEDMODE 353
1928#define XINE_EVENT_VDR_PLUGINSTARTED 354
1929#define XINE_EVENT_VDR_DISCONTINUITY 355
1930
1931/* events generated from post plugins */
1932#define XINE_EVENT_POST_TVTIME_FILMMODE_CHANGE 400
1933
1934/*
1935 * xine event struct
1936 */
1937typedef struct {
1938 xine_stream_t *stream; /* stream this event belongs to */
1939
1940 void *data; /* contents depending on type */
1942
1943 int type; /* event type (constants see above) */
1944
1945 /* you do not have to provide this, it will be filled in by xine_event_send() */
1946 struct timeval tv; /* timestamp of event creation */
1947} xine_event_t;
1948
1949/*
1950 * input event dynamic data
1951 */
1952typedef struct {
1954 uint8_t button; /* Generally 1 = left, 2 = mid, 3 = right */
1955 uint16_t x,y; /* In Image space */
1957
1958/*
1959 * UI event dynamic data - send information to/from UI.
1960 */
1961typedef struct {
1964 char str[256]; /* might be longer */
1966
1967/*
1968 * Send messages to UI. used mostly to report errors.
1969 */
1970typedef struct {
1971 /*
1972 * old xine-ui versions expect xine_ui_data_t type.
1973 * this struct is added for compatibility.
1974 */
1976
1977 /* See XINE_MSG_xxx for defined types. */
1978 int type;
1979
1980 /* defined types are provided with a standard explanation.
1981 * note: zero means no explanation.
1982 */
1983 int explanation; /* add to struct address to get a valid (char *) */
1984
1985 /* parameters are zero terminated strings */
1987 int parameters; /* add to struct address to get a valid (char *) */
1988
1989 /* where messages are stored, will be longer
1990 *
1991 * this field begins with the message text itself (\0-terminated),
1992 * followed by (optional) \0-terminated parameter strings
1993 * the end marker is \0 \0
1994 */
1995 char messages[1];
1997
1998
1999/*
2000 * notify frame format change
2001 */
2002typedef struct {
2005 /* these are aspect codes as defined in MPEG2, because this
2006 * is only used for DVD playback, pan_scan is a boolean flag */
2010
2011/*
2012 * audio level for left/right channel
2013 */
2014typedef struct {
2015 int left;
2016 int right; /* 0..100 % */
2017 int mute;
2019
2020/*
2021 * index generation / buffering
2022 */
2023typedef struct {
2024 const char *description; /* e.g. "connecting..." */
2027
2028/*
2029 * nbc buffer status
2030 */
2031typedef struct {
2032 int v_percent; /* fill of video buffer */
2033 int64_t v_remaining; /* remaining time in ms till underrun */
2034 int64_t v_bitrate; /* current bitrate */
2035 int v_in_disc; /* in discontinuity */
2036 int a_percent; /* like video, but for audio */
2038 int64_t a_bitrate;
2040 int buffering; /* currently filling buffer */
2041 int enabled; /* buffer disabled by engine */
2042 int type; /* 0=buffer put, 1=buffer get */
2044
2045/*
2046 * mrl reference data is sent by demuxers when a reference stream is found.
2047 * this stream just contains pointers (urls) to the real data, which are
2048 * passed to frontend using this event type. (examples: .asx, .mov and .ram)
2049 *
2050 * ideally, frontends should add these mrls to a "hierarchical playlist".
2051 * that is, instead of the original file, the ones provided here should be
2052 * played instead. on pratice, just using a simple playlist should work.
2053 *
2054 * mrl references should be played in the same order they are received, just
2055 * after the current stream finishes.
2056 * alternative entries may be provided and should be used in case of
2057 * failure of the primary stream (the one with alternative=0).
2058 *
2059 * sample playlist:
2060 * 1) http://something/something.ram
2061 * 1a) rtsp://something/realsomething1.rm (alternative=0)
2062 * 1b) pnm://something/realsomething1.rm (alternative=1)
2063 * 2) http://another/another.avi
2064 *
2065 * 1 and 2 are the original items on this playlist. 1a and 1b were received
2066 * by events (they are the mrl references enclosed in 1). 1a is played after
2067 * receiving the finished event from 1. note: 1b is usually ignored, it should
2068 * only be used in case 1a fails to open.
2069 *
2070 * An event listener which accepts XINE_EVENT_MRL_REFERENCE_EXT events
2071 * *must* ignore XINE_EVENT_MRL_REFERENCE events.
2072 */
2073typedef struct {
2074 int alternative; /* alternative playlist number, usually 0 */
2075 char mrl[1]; /* might (will) be longer */
2077
2078typedef struct {
2079 int alternative; /* as above */
2080 uint32_t start_time, duration; /* milliseconds */
2081 uint32_t spare[20]; /* for future expansion */
2082 const char mrl[1]; /* might (will) be longer */
2083/*const char title[]; ** immediately follows MRL's terminating NUL */
2085
2086/*
2087 * configuration options for video4linux-like input plugins
2088 */
2089typedef struct {
2090 /* input selection */
2091 int input; /* select active input from card */
2092 int channel; /* channel number */
2093 int radio; /* ask for a radio channel */
2094 uint32_t frequency; /* frequency divided by 62.5KHz or 62.5 Hz */
2095 uint32_t transmission; /* The transmission standard. */
2096
2097 /* video parameters */
2098 uint32_t framerate_numerator; /* framerate as numerator/denominator */
2100 uint32_t framelines; /* Total lines per frame including blanking */
2101 uint64_t standard_id; /* One of the V4L2_STD_* values */
2102 uint32_t colorstandard; /* One of the V4L2_COLOR_STD_* values */
2103 uint32_t colorsubcarrier; /* The color subcarrier frequency */
2104 int frame_width; /* scaled frame width */
2105 int frame_height; /* scaled frame height */
2106
2107 /* let some spare space so we can add new fields without breaking
2108 * binary api compatibility.
2109 */
2110 uint32_t spare[20];
2111
2112 /* used by pvr plugin */
2113 int32_t session_id; /* -1 stops pvr recording */
2114
2116
2117/*
2118 * configuration options for plugins that can do a kind of mpeg encoding
2119 * note: highly experimental api :)
2120 */
2121typedef struct {
2122
2123 /* mpeg2 parameters */
2124 int bitrate_vbr; /* 1 = vbr, 0 = cbr */
2125 int bitrate_mean; /* mean (target) bitrate in kbps*/
2126 int bitrate_peak; /* peak (max) bitrate in kbps */
2127 int gop_size; /* GOP size in frames */
2128 int gop_closure; /* open/closed GOP */
2129 int b_frames; /* number of B frames to use */
2130 int aspect_ratio; /* XINE_VO_ASPECT_xxx */
2131
2132 /* let some spare space so we can add new fields without breaking
2133 * binary api compatibility.
2134 */
2135 uint32_t spare[20];
2136
2138
2139typedef struct {
2140 int direction; /* 0 leave, 1 enter */
2141 int32_t button; /* button number */
2143
2144#ifdef XINE_ENABLE_EXPERIMENTAL_FEATURES
2145
2146/*
2147 * ask pvr to save (ie. do not discard) the current session
2148 * see comments on input_pvr.c to understand how it works.
2149 */
2150typedef struct {
2151 /* mode values:
2152 * -1 = do nothing, just set the name
2153 * 0 = truncate current session and save from now on
2154 * 1 = save from last sync point
2155 * 2 = save everything on current session
2156 */
2157 int mode;
2158 int id;
2159 char name[256]; /* name for saving, might be longer */
2160} xine_pvr_save_data_t;
2161
2162typedef struct {
2163 /* mode values:
2164 * 0 = non realtime
2165 * 1 = realtime
2166 */
2167 int mode;
2168} xine_pvr_realtime_t;
2169
2170typedef struct {
2171 /* mode values:
2172 * 0 = playing
2173 * 1 = paused
2174 */
2175 int mode;
2176} xine_pvr_pause_t;
2177
2178#endif
2179
2180/* event XINE_EVENT_DROPPED_FRAMES is generated if libxine detects a
2181 * high number of dropped frames (above configured thresholds). it can
2182 * be used by the front end to warn about performance problems.
2183 */
2184typedef struct {
2185 /* these values are given for 1000 frames delivered */
2186 /* (that is, divide by 10 to get percentages) */
2192
2193
2194/*
2195 * Defined message types for XINE_EVENT_UI_MESSAGE
2196 * This is the mechanism to report async errors from engine.
2197 *
2198 * If frontend knows about the XINE_MSG_xxx type it may safely
2199 * ignore the 'explanation' field and provide its own custom
2200 * dialogue to the 'parameters'.
2201 *
2202 * right column specifies the usual parameters.
2203 */
2204
2205#define XINE_MSG_NO_ERROR 0 /* (messages to UI) */
2206#define XINE_MSG_GENERAL_WARNING 1 /* (warning message) */
2207#define XINE_MSG_UNKNOWN_HOST 2 /* (host name) */
2208#define XINE_MSG_UNKNOWN_DEVICE 3 /* (device name) */
2209#define XINE_MSG_NETWORK_UNREACHABLE 4 /* none */
2210#define XINE_MSG_CONNECTION_REFUSED 5 /* (host name) */
2211#define XINE_MSG_FILE_NOT_FOUND 6 /* (file name or mrl) */
2212#define XINE_MSG_READ_ERROR 7 /* (device/file/mrl) */
2213#define XINE_MSG_LIBRARY_LOAD_ERROR 8 /* (library/decoder) */
2214#define XINE_MSG_ENCRYPTED_SOURCE 9 /* none */
2215#define XINE_MSG_SECURITY 10 /* (security message) */
2216#define XINE_MSG_AUDIO_OUT_UNAVAILABLE 11 /* none */
2217#define XINE_MSG_PERMISSION_ERROR 12 /* (file name or mrl) */
2218#define XINE_MSG_FILE_EMPTY 13 /* file is empty */
2219#define XINE_MSG_AUTHENTICATION_NEEDED 14 /* (mrl, likely http) */
2220
2221/* opaque xine_event_queue_t */
2223
2224/*
2225 * register a new event queue
2226 *
2227 * you have to receive messages from this queue regularly
2228 *
2229 * use xine_event_dispose_queue to unregister and free the queue
2230 */
2233
2237void xine_event_select (xine_event_queue_t *queue, const int *types) XINE_PROTECTED;
2238
2239/*
2240 * receive events (poll)
2241 *
2242 * use xine_event_free on the events received from these calls
2243 * when they're no longer needed
2244 */
2245/* get first event or NULL when queue is empty. */
2247/* free prev_event if not NULL, then same as xine_event_get (). */
2249/* get first event, wait for it if needed. */
2251/* free or reuse event. may be NULL. */
2253
2254/*
2255 * receive events (callback)
2256 *
2257 * a thread is created which will receive all events from
2258 * the specified queue, call your callback on each of them
2259 * and will then free the event when your callback returns
2260 *
2261 * Note: only one listener thread / event queue !
2262 *
2263 * @return 0 on error
2264 */
2266 const xine_event_t *event);
2270
2271/*
2272 * send an event to all queues
2273 *
2274 * the event will be copied so you can free or reuse
2275 * *event as soon as xine_event_send returns.
2276 */
2278
2279
2280
2281/*********************************************************************
2282 * OSD (on screen display) *
2283 *********************************************************************/
2284
2285#define XINE_TEXT_PALETTE_SIZE 11
2286
2287#define XINE_OSD_TEXT1 (0 * XINE_TEXT_PALETTE_SIZE)
2288#define XINE_OSD_TEXT2 (1 * XINE_TEXT_PALETTE_SIZE)
2289#define XINE_OSD_TEXT3 (2 * XINE_TEXT_PALETTE_SIZE)
2290#define XINE_OSD_TEXT4 (3 * XINE_TEXT_PALETTE_SIZE)
2291#define XINE_OSD_TEXT5 (4 * XINE_TEXT_PALETTE_SIZE)
2292#define XINE_OSD_TEXT6 (5 * XINE_TEXT_PALETTE_SIZE)
2293#define XINE_OSD_TEXT7 (6 * XINE_TEXT_PALETTE_SIZE)
2294#define XINE_OSD_TEXT8 (7 * XINE_TEXT_PALETTE_SIZE)
2295#define XINE_OSD_TEXT9 (8 * XINE_TEXT_PALETTE_SIZE)
2296#define XINE_OSD_TEXT10 (9 * XINE_TEXT_PALETTE_SIZE)
2297
2298/* white text, black border, transparent background */
2299#define XINE_TEXTPALETTE_WHITE_BLACK_TRANSPARENT 0
2300/* white text, noborder, transparent background */
2301#define XINE_TEXTPALETTE_WHITE_NONE_TRANSPARENT 1
2302/* white text, no border, translucid background */
2303#define XINE_TEXTPALETTE_WHITE_NONE_TRANSLUCID 2
2304/* yellow text, black border, transparent background */
2305#define XINE_TEXTPALETTE_YELLOW_BLACK_TRANSPARENT 3
2306
2307#define XINE_OSD_CAP_FREETYPE2 0x0001 /* freetype2 support compiled in */
2308#define XINE_OSD_CAP_UNSCALED 0x0002 /* unscaled overlays supp. by vo drv */
2309#define XINE_OSD_CAP_CUSTOM_EXTENT 0x0004 /* hardware scaled to match video output window */
2310#define XINE_OSD_CAP_ARGB_LAYER 0x0008 /* supports ARGB true color pixmaps */
2311#define XINE_OSD_CAP_VIDEO_WINDOW 0x0010 /* can scale video to an area within osd extent */
2312
2313typedef struct xine_osd_s xine_osd_t;
2314
2315xine_osd_t *xine_osd_new (xine_stream_t *self, int x, int y,
2316 int width, int height) XINE_PROTECTED;
2318void xine_osd_draw_point (xine_osd_t *self, int x, int y, int color) XINE_PROTECTED;
2319
2320void xine_osd_draw_line (xine_osd_t *self, int x1, int y1,
2321 int x2, int y2, int color) XINE_PROTECTED;
2322void xine_osd_draw_rect (xine_osd_t *self, int x1, int y1,
2323 int x2, int y2,
2324 int color, int filled ) XINE_PROTECTED;
2325/* x1 and y1 specifies the upper left corner of the text to be rendered */
2326void xine_osd_draw_text (xine_osd_t *self, int x1, int y1,
2327 const char *text, int color_base) XINE_PROTECTED;
2328void xine_osd_draw_bitmap (xine_osd_t *self, uint8_t *bitmap,
2329 int x1, int y1, int width, int height,
2330 uint8_t *palette_map) XINE_PROTECTED;
2331/* for freetype2 fonts the height is the maximum height for the whole font and not
2332 * only for the specified text */
2333void xine_osd_get_text_size (xine_osd_t *self, const char *text,
2334 int *width, int *height) XINE_PROTECTED;
2335/* with freetype2 support compiled in, you can also specify a font file
2336 as 'fontname' here */
2337int xine_osd_set_font (xine_osd_t *self, const char *fontname,
2338 int size) XINE_PROTECTED;
2339/*
2340 * specifying encoding of texts
2341 * "" ... means current locale encoding (default)
2342 * NULL ... means latin1
2343 */
2344void xine_osd_set_encoding(xine_osd_t *self, const char *encoding) XINE_PROTECTED;
2345/* set position were overlay will be blended */
2346void xine_osd_set_position (xine_osd_t *self, int x, int y) XINE_PROTECTED;
2347void xine_osd_show (xine_osd_t *self, int64_t vpts) XINE_PROTECTED;
2348void xine_osd_show_unscaled (xine_osd_t *self, int64_t vpts) XINE_PROTECTED;
2349void xine_osd_hide (xine_osd_t *self, int64_t vpts) XINE_PROTECTED;
2350/* empty drawing area */
2352/*
2353 * set on existing text palette
2354 * (-1 to set used specified palette)
2355 *
2356 * color_base specifies the first color index to use for this text
2357 * palette. The OSD palette is then modified starting at this
2358 * color index, up to the size of the text palette.
2359 *
2360 * Use OSD_TEXT1, OSD_TEXT2, ... for some preassigned color indices.
2361 *
2362 * These palettes are not working well with the true type fonts.
2363 * First thing is that these fonts cannot have a border. So you get
2364 * the best results by loading a linearly blending palette from the
2365 * background (at index 0) to the forground color (at index 10).
2366 */
2368 int palette_number,
2369 int color_base ) XINE_PROTECTED;
2370/* get palette (color and transparency) */
2371void xine_osd_get_palette (xine_osd_t *self, uint32_t *color,
2372 uint8_t *trans) XINE_PROTECTED;
2374 const uint32_t *const color,
2375 const uint8_t *const trans ) XINE_PROTECTED;
2376
2377/*
2378 * Set an ARGB buffer to be blended into video.
2379 * The buffer must stay valid while the OSD is on screen.
2380 * Pass a NULL pointer to safely remove the buffer from
2381 * the OSD layer. Only the dirty area will be
2382 * updated on screen. For convenience the whole
2383 * OSD object will be considered dirty when setting
2384 * a different buffer pointer.
2385 * see also XINE_OSD_CAP_ARGB_LAYER
2386 */
2387void xine_osd_set_argb_buffer(xine_osd_t *self, uint32_t *argb_buffer,
2388 int dirty_x, int dirty_y, int dirty_width, int dirty_height) XINE_PROTECTED;
2389
2390/*
2391 * define extent of reference coordinate system
2392 * for video resolution independent osds.
2393 * see also XINE_OSD_CAP_CUSTOM_EXTENT
2394 */
2395void xine_osd_set_extent(xine_osd_t *self, int extent_width, int extent_height) XINE_PROTECTED;
2396
2397/*
2398 * define area within osd extent to output
2399 * video to while osd is on screen
2400 * see also XINE_OSD_CAP_VIDEO_WINDOW
2401 */
2402void xine_osd_set_video_window(xine_osd_t *self, int window_x, int window_y, int window_width, int window_height) XINE_PROTECTED;
2403
2404/*
2405 * close osd rendering engine
2406 * loaded fonts are unloaded
2407 * osd objects are closed
2408 */
2410
2411#ifdef __cplusplus
2412}
2413#endif
2414
2415#endif
aspect_ratio
Definition: alterh264_decode.h:48
int xine_get_next_audio_frame(xine_audio_port_t *this_gen, xine_audio_frame_t *frame)
Definition: audio_out.c:2155
void xine_free_audio_frame(xine_audio_port_t *this_gen, xine_audio_frame_t *frame)
Definition: audio_out.c:2231
unsigned int height
Definition: gfontrle.c:5
unsigned int width
Definition: gfontrle.c:4
#define XINE_DEPRECATED
Definition: attributes.h:87
#define XINE_PROTECTED
Definition: attributes.h:75
#define XINE_FORMAT_PRINTF(fmt, var)
Definition: attributes.h:129
#define XINE_WEAK
Definition: attributes.h:101
xine_audio_port_t * xine_new_framegrab_audio_port(xine_t *this)
Definition: load_plugins.c:2525
xine_video_port_t * xine_new_framegrab_video_port(xine_t *this)
Definition: load_plugins.c:2347
const char name[16]
Definition: memcpy.c:570
static int set_parameters(xine_post_t *this_gen, const void *param_gen)
Definition: stretch.c:235
static int get_parameters(xine_post_t *this_gen, void *param_gen)
Definition: stretch.c:246
Definition: xine.h:1506
void * user_data
Definition: xine.h:1516
Definition: xine.h:1445
int ovl_x
Definition: xine.h:1448
uint8_t * ovl_rgba
Definition: xine.h:1446
int ovl_h
Definition: xine.h:1447
Definition: xine.h:1455
void * user_data
Definition: xine.h:1456
int supported_formats
Definition: xine.h:1466
Definition: xine.h:1225
int h
Definition: xine.h:1228
Definition: xine.h:1237
void * user_data
Definition: xine.h:1246
int screen
Definition: xine.h:1241
unsigned long d
Definition: xine.h:1244
void * display
Definition: xine.h:1240
Definition: xine.h:1337
void * user_data
Definition: xine.h:1346
void * connection
Definition: xine.h:1340
unsigned int window
Definition: xine.h:1344
void * screen
Definition: xine.h:1341
Definition: xine.h:2014
int right
Definition: xine.h:2016
int mute
Definition: xine.h:2017
int left
Definition: xine.h:2015
Definition: audio_out.h:172
Definition: xine.h:1632
char * str_default
Definition: xine.h:1647
char * str_value
Definition: xine.h:1646
int range_min
Definition: xine.h:1657
const char * help
Definition: xine.h:1668
char ** enum_values
Definition: xine.h:1661
int exp_level
Definition: xine.h:1638
xine_config_cb_t callback
Definition: xine.h:1676
int type
Definition: xine.h:1635
const char * description
Definition: xine.h:1667
const char * key
Definition: xine.h:1633
int range_max
Definition: xine.h:1658
char * unknown_value
Definition: xine.h:1643
int num_default
Definition: xine.h:1654
int num_value
Definition: xine.h:1653
void * callback_data
Definition: xine.h:1677
Definition: xine.h:1792
const char * new_name
Definition: xine.h:1793
Definition: xine.h:473
int ratio_code
Definition: xine.h:480
int img_size
Definition: xine.h:483
uint8_t * img
Definition: xine.h:484
int width
Definition: xine.h:474
int crop_top
Definition: xine.h:478
int format
Definition: xine.h:482
int crop_right
Definition: xine.h:477
int crop_left
Definition: xine.h:476
int height
Definition: xine.h:475
int crop_bottom
Definition: xine.h:479
int interlaced
Definition: xine.h:481
Definition: xine.h:2184
int skipped_threshold
Definition: xine.h:2188
int discarded_frames
Definition: xine.h:2189
int discarded_threshold
Definition: xine.h:2190
int skipped_frames
Definition: xine.h:2187
Definition: xine_internal.h:107
xine_stream_t * stream
Definition: xine_internal.h:112
xine_event_listener_cb_t callback
Definition: xine_internal.h:115
Definition: xine.h:1937
int data_length
Definition: xine.h:1941
xine_stream_t * stream
Definition: xine.h:1938
int type
Definition: xine.h:1943
void * data
Definition: xine.h:1940
Definition: xine.h:2002
int aspect
Definition: xine.h:2007
int height
Definition: xine.h:2004
int width
Definition: xine.h:2003
int pan_scan
Definition: xine.h:2008
Definition: xine.h:539
int crop_bottom
Definition: xine.h:557
int width
Definition: xine.h:566
int crop_top
Definition: xine.h:556
int height
Definition: xine.h:566
void(* dispose)(xine_grab_video_frame_t *self)
Definition: xine.h:549
uint8_t * img
Definition: xine.h:567
int64_t vpts
Definition: xine.h:568
int crop_right
Definition: xine.h:555
int(* grab)(xine_grab_video_frame_t *self)
Definition: xine.h:544
int timeout
Definition: xine.h:570
int crop_left
Definition: xine.h:554
int flags
Definition: xine.h:571
Definition: xine.h:1594
const char * cdrom_dev
Definition: xine.h:1595
const char * msg
Definition: xine.h:1597
const char * title
Definition: xine.h:1598
const char * dvd_dev
Definition: xine.h:1596
int status
Definition: xine.h:1600
const char * explanation
Definition: xine.h:1599
Definition: xine.h:1952
uint8_t button
Definition: xine.h:1954
uint16_t x
Definition: xine.h:1955
xine_event_t event
Definition: xine.h:1953
Definition: xine.h:244
int normpos
Definition: xine.h:246
int msecs
Definition: xine.h:245
Definition: xine.h:2078
uint32_t duration
Definition: xine.h:2080
int alternative
Definition: xine.h:2079
Definition: xine.h:2073
int alternative
Definition: xine.h:2074
Definition: xine.h:1107
off_t size
Definition: xine.h:1111
char * origin
Definition: xine.h:1108
char * mrl
Definition: xine.h:1109
uint32_t type
Definition: xine.h:1112
char * link
Definition: xine.h:1110
Definition: xine.h:2031
int64_t v_remaining
Definition: xine.h:2033
int64_t a_remaining
Definition: xine.h:2037
int enabled
Definition: xine.h:2041
int v_percent
Definition: xine.h:2032
int64_t v_bitrate
Definition: xine.h:2034
int buffering
Definition: xine.h:2040
int v_in_disc
Definition: xine.h:2035
int64_t a_bitrate
Definition: xine.h:2038
int a_percent
Definition: xine.h:2036
int a_in_disc
Definition: xine.h:2039
int type
Definition: xine.h:2042
Definition: osd.h:78
Definition: xine.h:867
xine_post_api_parameter_t * parameter
Definition: xine.h:869
int struct_size
Definition: xine.h:868
Definition: xine.h:854
double range_max
Definition: xine.h:861
int readonly
Definition: xine.h:862
const char * description
Definition: xine.h:863
const char * name
Definition: xine.h:856
int type
Definition: xine.h:855
double range_min
Definition: xine.h:860
int size
Definition: xine.h:857
int offset
Definition: xine.h:858
char ** enum_values
Definition: xine.h:859
Definition: xine.h:872
Definition: xine.h:721
void * data
Definition: xine.h:728
int type
Definition: xine.h:731
const char * name
Definition: xine.h:724
Definition: xine.h:735
void * data
Definition: xine.h:742
const char * name
Definition: xine.h:738
int type
Definition: xine.h:756
int(* rewire)(xine_post_out_t *self, void *data)
Definition: xine.h:753
Definition: xine.h:667
xine_audio_port_t ** audio_input
Definition: xine.h:673
int type
Definition: xine.h:684
xine_video_port_t ** video_input
Definition: xine.h:679
Definition: xine.h:2023
int percent
Definition: xine.h:2025
const char * description
Definition: xine.h:2024
Definition: xine_internal.h:80
Definition: xine.h:2121
int b_frames
Definition: xine.h:2129
int gop_closure
Definition: xine.h:2128
int gop_size
Definition: xine.h:2127
int bitrate_peak
Definition: xine.h:2126
int bitrate_mean
Definition: xine.h:2125
int bitrate_vbr
Definition: xine.h:2124
int aspect_ratio
Definition: xine.h:2130
Definition: xine.h:2089
uint32_t colorsubcarrier
Definition: xine.h:2103
uint32_t framelines
Definition: xine.h:2100
uint32_t transmission
Definition: xine.h:2095
int input
Definition: xine.h:2091
uint32_t framerate_numerator
Definition: xine.h:2098
int frame_width
Definition: xine.h:2104
int frame_height
Definition: xine.h:2105
uint64_t standard_id
Definition: xine.h:2101
uint32_t framerate_denominator
Definition: xine.h:2099
int radio
Definition: xine.h:2093
int channel
Definition: xine.h:2092
uint32_t frequency
Definition: xine.h:2094
uint32_t colorstandard
Definition: xine.h:2102
int32_t session_id
Definition: xine.h:2113
Definition: xine.h:2139
int direction
Definition: xine.h:2140
int32_t button
Definition: xine.h:2141
Definition: xine_internal.h:123
Definition: xine.h:1961
int num_buttons
Definition: xine.h:1962
int str_len
Definition: xine.h:1963
Definition: xine.h:1970
int explanation
Definition: xine.h:1983
xine_ui_data_t compatibility
Definition: xine.h:1975
int num_parameters
Definition: xine.h:1986
int parameters
Definition: xine.h:1987
int type
Definition: xine.h:1978
Definition: video_out.h:176
vo_driver_t * driver
Definition: video_out.h:236
Definition: xine.h:1417
struct wl_surface * surface
Definition: xine.h:1420
void * user_data
Definition: xine.h:1422
struct wl_display * display
Definition: xine.h:1419
static void user_data(vdpau_mpeg4_decoder_t *this_gen, uint8_t *buffer, int len)
Definition: vdpau_mpeg4.c:695
int xine_get_next_video_frame(xine_video_port_t *this_gen, xine_video_frame_t *frame)
Definition: video_out.c:2564
void xine_free_video_frame(xine_video_port_t *port, xine_video_frame_t *frame)
Definition: video_out.c:2619
int xine_config_get_next_entry(xine_t *self, xine_cfg_entry_t *entry)
Definition: xine_interface.c:257
xine_post_out_t * xine_get_audio_source(xine_stream_t *stream)
Definition: xine_interface.c:1003
const char *const * xine_get_autoplay_input_plugin_ids(xine_t *self)
Definition: load_plugins.c:2161
void xine_init(xine_t *self)
Definition: xine.c:2688
const char * xine_config_register_string(xine_t *self, const char *key, const char *def_value, const char *description, const char *help, int exp_level, xine_config_cb_t changed_cb, void *cb_data)
Definition: xine_interface.c:79
const char * xine_get_video_driver_plugin_description(xine_t *self, const char *plugin_id)
Definition: load_plugins.c:3060
int xine_get_current_frame_alloc(xine_stream_t *stream, int *width, int *height, int *ratio_code, int *format, uint8_t **img, int *img_size)
Definition: xine.c:3217
int xine_get_current_frame(xine_stream_t *stream, int *width, int *height, int *ratio_code, int *format, uint8_t *img) XINE_DEPRECATED
Definition: xine.c:3256
void(* xine_log_cb_t)(void *user_data, int section)
Definition: xine.h:931
const char *const * xine_list_spu_plugins(xine_t *self)
Definition: load_plugins.c:2990
xine_stream_t * xine_get_side_stream(xine_stream_t *master, int index)
Definition: xine.c:1269
void(* xine_event_listener_cb_t)(void *user_data, const xine_event_t *event)
Definition: xine.h:2265
void xine_osd_set_encoding(xine_osd_t *self, const char *encoding)
Definition: xine_interface.c:865
int xine_get_status(xine_stream_t *stream)
Definition: xine.c:2895
void xine_osd_show_unscaled(xine_osd_t *self, int64_t vpts)
Definition: xine_interface.c:877
void xine_osd_set_argb_buffer(xine_osd_t *self, uint32_t *argb_buffer, int dirty_x, int dirty_y, int dirty_width, int dirty_height)
Definition: xine_interface.c:911
int xine_get_audio_lang(xine_stream_t *stream, int channel, char *lang)
Definition: xine.c:3366
xine_event_t * xine_event_get(xine_event_queue_t *queue)
Definition: events.c:70
void xine_dispose(xine_stream_t *stream)
Definition: xine.c:2391
void xine_osd_set_text_palette(xine_osd_t *self, int palette_number, int color_base)
Definition: xine_interface.c:897
xine_stream_t * xine_stream_new(xine_t *self, xine_audio_port_t *ao, xine_video_port_t *vo)
Definition: xine.c:1029
const char * xine_config_register_filename(xine_t *self, const char *key, const char *def_value, int req_type, const char *description, const char *help, int exp_level, xine_config_cb_t changed_cb, void *cb_data)
Definition: xine_interface.c:99
void xine_event_send(xine_stream_t *stream, const xine_event_t *event)
Definition: events.c:238
char * xine_get_demux_for_mime_type(xine_t *self, const char *mime_type)
Definition: load_plugins.c:3239
char * xine_get_file_extensions(xine_t *self)
Definition: load_plugins.c:3223
int xine_config_lookup_num(xine_t *self, const char *key, int def_value)
Definition: xine_interface.c:188
void xine_osd_draw_text(xine_osd_t *self, int x1, int y1, const char *text, int color_base)
Definition: xine_interface.c:853
void xine_osd_hide(xine_osd_t *self, int64_t vpts)
Definition: xine_interface.c:881
int xine_open(xine_stream_t *stream, const char *mrl)
Definition: xine.c:1969
const char *const * xine_get_log_names(xine_t *self)
Definition: xine.c:3396
int xine_config_register_bool(xine_t *self, const char *key, int def_value, const char *description, const char *help, int exp_level, xine_config_cb_t changed_cb, void *cb_data)
Definition: xine_interface.c:162
void xine_osd_draw_line(xine_osd_t *self, int x1, int y1, int x2, int y2, int color)
Definition: xine_interface.c:838
const char *const * xine_list_demuxer_plugins(xine_t *self)
Definition: load_plugins.c:2982
xine_health_check_t * xine_health_check(xine_health_check_t *, int check_num)
Definition: xine_check.c:504
const char * xine_get_post_plugin_description(xine_t *self, const char *plugin_id)
Definition: load_plugins.c:3061
void xine_close(xine_stream_t *stream)
Definition: xine.c:920
void xine_osd_set_position(xine_osd_t *self, int x, int y)
Definition: xine_interface.c:869
const char *const * xine_list_audio_decoder_plugins(xine_t *self)
Definition: load_plugins.c:2994
void xine_osd_free(xine_osd_t *self)
Definition: xine_interface.c:889
void xine_event_select(xine_event_queue_t *queue, const int *types)
Filter events by type.
Definition: events.c:488
int xine_get_pos_length(xine_stream_t *stream, int *pos_stream, int *pos_time, int *length_time)
Definition: xine.c:3010
int xine_config_lookup_entry(xine_t *self, const char *key, xine_cfg_entry_t *entry)
Definition: xine_interface.c:283
xine_post_out_t * xine_post_output(xine_post_t *self, const char *name)
Definition: xine_interface.c:947
const char *const * xine_get_browsable_input_plugin_ids(xine_t *self)
Definition: load_plugins.c:2210
xine_post_t * xine_post_init(xine_t *xine, const char *name, int inputs, xine_audio_port_t **audio_target, xine_video_port_t **video_target)
Definition: load_plugins.c:3063
int xine_post_wire(xine_post_out_t *source, xine_post_in_t *target)
Definition: xine_interface.c:959
const char *const * xine_post_list_inputs(xine_post_t *self)
Definition: xine_interface.c:925
void xine_osd_draw_point(xine_osd_t *self, int x, int y, int color)
Definition: xine_interface.c:834
int xine_get_spu_lang(xine_stream_t *stream, int channel, char *lang)
Definition: xine.c:3328
const char * xine_get_audio_plugin_description(xine_t *self, const char *plugin_id)
Definition: load_plugins.c:3057
xine_t * xine_new(void)
Definition: xine.c:2533
void xine_engine_set_param(xine_t *self, int param, int value)
Definition: xine.c:2595
void xine_osd_clear(xine_osd_t *self)
Definition: xine_interface.c:885
int xine_get_param(xine_stream_t *stream, int param)
Definition: xine_interface.c:578
void xine_event_dispose_queue(xine_event_queue_t *queue)
Definition: events.c:526
const char *const * xine_list_video_output_plugins(xine_t *self)
Definition: load_plugins.c:2392
int xine_config_register_enum(xine_t *self, const char *key, int def_value, char **values, const char *description, const char *help, int exp_level, xine_config_cb_t changed_cb, void *cb_data)
Definition: xine_interface.c:131
char * xine_config_lookup_string(xine_t *self, const char *key)
Definition: xine_interface.c:192
void xine_close_audio_driver(xine_t *self, xine_audio_port_t *driver)
Definition: load_plugins.c:2568
xine_event_queue_t * xine_event_new_queue(xine_stream_t *stream)
Definition: events.c:426
void xine_config_reset(xine_t *self)
Definition: xine_interface.c:327
void xine_plugins_garbage_collector(xine_t *self)
Definition: load_plugins.c:2880
void xine_close_video_driver(xine_t *self, xine_video_port_t *driver)
Definition: load_plugins.c:2576
const char * xine_get_video_plugin_description(xine_t *self, const char *plugin_id)
Definition: load_plugins.c:3058
int xine_config_register_range(xine_t *self, const char *key, int def_value, int min, int max, const char *description, const char *help, int exp_level, xine_config_cb_t changed_cb, void *cb_data)
Definition: xine_interface.c:115
int xine_check_version(int major, int minor, int sub)
Definition: xine_interface.c:65
xine_keyframes_entry_t * xine_keyframes_get(xine_stream_t *stream, int *size)
Get a private stream keyframe seek index copy, free () it when done.
Definition: xine.c:3799
void xine_osd_get_text_size(xine_osd_t *self, const char *text, int *width, int *height)
Definition: xine_interface.c:857
const char * xine_get_input_plugin_description(xine_t *self, const char *plugin_id)
Definition: load_plugins.c:3054
int xine_post_wire_video_port(xine_post_out_t *source, xine_video_port_t *vo)
Definition: xine_interface.c:972
int xine_engine_get_param(xine_t *self, int param)
Definition: xine.c:2611
uint32_t xine_osd_get_capabilities(xine_osd_t *self)
Definition: xine_interface.c:830
int xine_config_register_num(xine_t *self, const char *key, int def_value, const char *description, const char *help, int exp_level, xine_config_cb_t changed_cb, void *cb_data)
Definition: xine_interface.c:147
int xine_post_wire_audio_port(xine_post_out_t *source, xine_audio_port_t *ao)
Definition: xine_interface.c:985
int xine_keyframes_find(xine_stream_t *stream, xine_keyframes_entry_t *pos, int offs)
Query stream keyframe seek index.
Definition: xine.c:3671
int xine_get_error(xine_stream_t *stream)
Definition: xine.c:3472
void xine_osd_set_extent(xine_osd_t *self, int extent_width, int extent_height)
Definition: xine_interface.c:916
void xine_osd_get_palette(xine_osd_t *self, uint32_t *color, uint8_t *trans)
Definition: xine_interface.c:901
const char *const * xine_get_autoplay_mrls(xine_t *self, const char *plugin_id, int *num_mrls)
Definition: load_plugins.c:2611
const char *const * xine_list_video_output_plugins_typed(xine_t *self, uint64_t typemask)
Definition: load_plugins.c:2396
void xine_config_update_entry(xine_t *self, const xine_cfg_entry_t *entry)
Definition: xine_interface.c:305
void xine_config_free_string(xine_t *self, char **value)
Definition: xine_interface.c:196
void xine_set_flags(xine_t *, int) XINE_WEAK
Definition: xine.c:2660
void xine_register_log_cb(xine_t *self, xine_log_cb_t cb, void *user_data)
Definition: xine.c:3466
void xine_log(xine_t *self, int buf, const char *format,...) XINE_FORMAT_PRINTF(3
const char *const * xine_list_post_plugins_typed(xine_t *xine, uint32_t type)
Definition: load_plugins.c:3006
const char *const * xine_list_video_decoder_plugins(xine_t *self)
Definition: load_plugins.c:2998
int xine_osd_set_font(xine_osd_t *self, const char *fontname, int size)
Definition: xine_interface.c:861
void xine_config_save(xine_t *self, const char *cfg_filename)
Definition: configfile.c:1558
char * xine_get_mime_types(xine_t *self)
Definition: load_plugins.c:3230
uint32_t xine_get_stream_info(xine_stream_t *stream, int info)
Definition: xine_interface.c:753
void xine_event_free(xine_event_t *event)
Definition: events.c:219
void xine_exit(xine_t *self)
Definition: xine.c:2448
void xine_set_param(xine_stream_t *stream, int param, int value)
Definition: xine_interface.c:372
int xine_eject(xine_stream_t *stream)
Definition: xine.c:2323
xine_post_out_t * xine_get_video_source(xine_stream_t *stream)
Definition: xine_interface.c:998
int xine_config_unregister_callbacks(xine_t *self, const char *key, xine_config_cb_t changed_cb, void *cb_data, size_t cb_data_size)
Definition: xine_interface.c:176
xine_post_in_t * xine_post_input(xine_post_t *self, const char *name)
Definition: xine_interface.c:935
void xine_osd_draw_bitmap(xine_osd_t *self, uint8_t *bitmap, int x1, int y1, int width, int height, uint8_t *palette_map)
Definition: xine_interface.c:905
int xine_get_current_frame_s(xine_stream_t *stream, int *width, int *height, int *ratio_code, int *format, uint8_t *img, int *img_size)
Definition: xine.c:3236
void void xine_vlog(xine_t *self, int buf, const char *format, va_list args) XINE_FORMAT_PRINTF(3
void xine_get_version(int *major, int *minor, int *sub)
Definition: xine_interface.c:59
xine_video_port_t * xine_open_video_driver(xine_t *self, const char *id, int visual, const void *data)
Definition: load_plugins.c:2327
xine_mrl_t ** xine_get_browse_mrls(xine_t *self, const char *plugin_id, const char *start_mrl, int *num_mrls)
Definition: load_plugins.c:2635
const char * xine_get_audio_driver_plugin_description(xine_t *self, const char *plugin_id)
Definition: load_plugins.c:3059
xine_audio_port_t * xine_open_audio_driver(xine_t *self, const char *id, const void *data)
Definition: load_plugins.c:2473
void(* xine_config_cb_t)(void *user_data, xine_cfg_entry_t *entry)
Definition: xine.h:1630
const char *const * xine_list_audio_output_plugins(xine_t *self)
Definition: load_plugins.c:2388
xine_event_t * xine_event_wait(xine_event_queue_t *queue)
Definition: events.c:185
int xine_get_current_frame_data(xine_stream_t *stream, xine_current_frame_data_t *data, int flags)
Definition: xine.c:3210
const char * xine_get_version_string(void)
Definition: xine_interface.c:51
const char *const * xine_post_list_outputs(xine_post_t *self)
Definition: xine_interface.c:930
const char * xine_get_demux_plugin_description(xine_t *self, const char *plugin_id)
Definition: load_plugins.c:3055
int xine_stream_master_slave(xine_stream_t *master, xine_stream_t *slave, int affection)
Definition: xine.c:3478
xine_osd_t * xine_osd_new(xine_stream_t *self, int x, int y, int width, int height)
Definition: xine_interface.c:823
xine_grab_video_frame_t * xine_new_grab_video_frame(xine_stream_t *stream)
Definition: xine.c:3273
const char *const * xine_list_post_plugins(xine_t *xine)
Definition: load_plugins.c:3002
const char * xine_get_spu_plugin_description(xine_t *self, const char *plugin_id)
Definition: load_plugins.c:3056
int xine_port_send_gui_data(xine_video_port_t *vo, int type, void *data)
Definition: xine_interface.c:348
void xine_osd_set_video_window(xine_osd_t *self, int window_x, int window_y, int window_width, int window_height)
Definition: xine_interface.c:920
xine_event_t * xine_event_next(xine_event_queue_t *queue, xine_event_t *prev_event)
Definition: events.c:96
const char * xine_get_meta_info(xine_stream_t *stream, int info)
Definition: xine_interface.c:819
int xine_config_get_first_entry(xine_t *self, xine_cfg_entry_t *entry)
Definition: xine_interface.c:236
void void char *const * xine_get_log(xine_t *self, int buf)
Definition: xine.c:3455
int xine_get_log_section_count(xine_t *self)
Definition: xine.c:3391
void xine_config_load(xine_t *self, const char *cfg_filename)
Definition: configfile.c:1446
int xine_event_create_listener_thread(xine_event_queue_t *queue, xine_event_listener_cb_t callback, void *user_data)
Definition: events.c:667
void xine_config_set_translation_user(const xine_config_entry_translation_t *)
Definition: configfile.c:1438
void xine_osd_set_palette(xine_osd_t *self, const uint32_t *const color, const uint8_t *const trans)
Definition: xine_interface.c:893
void xine_post_dispose(xine_t *xine, xine_post_t *self)
Definition: load_plugins.c:3140
void xine_osd_show(xine_osd_t *self, int64_t vpts)
Definition: xine_interface.c:873
int64_t xine_get_current_vpts(xine_stream_t *stream)
Definition: xine_interface.c:1099
void xine_stop(xine_stream_t *stream)
Definition: xine.c:788
const char *const * xine_list_input_plugins(xine_t *self)
Definition: load_plugins.c:2986
void xine_osd_draw_rect(xine_osd_t *self, int x1, int y1, int x2, int y2, int color, int filled)
Definition: xine_interface.c:842
int xine_play(xine_stream_t *stream, int start_pos, int start_time)
Definition: xine.c:2298
enable disable number of frames of telecine pattern sync required before mode change make frames evenly spaced for film mode(24 fps)" ) PARAM_ITEM( POST_PARAM_TYPE_BOOL
char key[16]
Definition: xine_speex_decoder.c:94