[bfb7fa]: src / xine-utils / xineutils.h  Maximize  Restore  History

Download this file

550 lines (470 with data), 19.9 kB

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
/*
* Copyright (C) 2000-2006 the xine project
*
* This file is part of xine, a free video player.
*
* xine is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* xine is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
*/
#ifndef XINEUTILS_H
#define XINEUTILS_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <pthread.h>
#ifdef XINE_COMPILE
# include <inttypes.h>
# include "attributes.h"
# include "compat.h"
# include "xmlparser.h"
# include "xine_buffer.h"
# include "configfile.h"
# include "list.h"
# include "array.h"
# include "sorted_array.h"
# include "xine_mmx.h"
#else
# ifdef WIN32
# include <winsock.h>
# else
# include <sys/time.h>
# endif
# include <xine/os_types.h>
# include <xine/attributes.h>
# include <xine/compat.h>
# include <xine/xmlparser.h>
# include <xine/xine_buffer.h>
# include <xine/configfile.h>
# include <xine/list.h>
# include <xine/array.h>
# include <xine/sorted_array.h>
# include <xine/xine_mmx.h>
#endif
#include <stdio.h>
#include <string.h>
/*
* Mark exported data symbols for link engine library clients with older
* Win32 compilers
*/
#if defined(WIN32) && !defined(XINE_LIBRARY_COMPILE)
# define DL_IMPORT __declspec(dllimport)
# define extern DL_IMPORT extern
#endif
/*
* debugable mutexes
*/
typedef struct {
pthread_mutex_t mutex;
char id[80];
char *locked_by;
} xine_mutex_t;
int xine_mutex_init (xine_mutex_t *mutex, const pthread_mutexattr_t *mutexattr,
const char *id) XINE_PROTECTED;
int xine_mutex_lock (xine_mutex_t *mutex, const char *who) XINE_PROTECTED;
int xine_mutex_unlock (xine_mutex_t *mutex, const char *who) XINE_PROTECTED;
int xine_mutex_destroy (xine_mutex_t *mutex) XINE_PROTECTED;
/* CPU Acceleration */
/*
* The type of an value that fits in an MMX register (note that long
* long constant values MUST be suffixed by LL and unsigned long long
* values by ULL, lest they be truncated by the compiler)
*/
/* generic accelerations */
#define MM_ACCEL_MLIB 0x00000001
/* x86 accelerations */
#define MM_ACCEL_X86_MMX 0x80000000
#define MM_ACCEL_X86_3DNOW 0x40000000
#define MM_ACCEL_X86_MMXEXT 0x20000000
#define MM_ACCEL_X86_SSE 0x10000000
#define MM_ACCEL_X86_SSE2 0x08000000
/* powerpc accelerations and features */
#define MM_ACCEL_PPC_ALTIVEC 0x04000000
#define MM_ACCEL_PPC_CACHE32 0x02000000
/* SPARC accelerations */
#define MM_ACCEL_SPARC_VIS 0x01000000
#define MM_ACCEL_SPARC_VIS2 0x00800000
/* x86 compat defines */
#define MM_MMX MM_ACCEL_X86_MMX
#define MM_3DNOW MM_ACCEL_X86_3DNOW
#define MM_MMXEXT MM_ACCEL_X86_MMXEXT
#define MM_SSE MM_ACCEL_X86_SSE
#define MM_SSE2 MM_ACCEL_X86_SSE2
uint32_t xine_mm_accel (void) XINE_CONST XINE_PROTECTED;
/* Optimized/fast memcpy */
extern void *(* xine_fast_memcpy)(void *to, const void *from, size_t len) XINE_PROTECTED;
#ifdef HAVE_XINE_INTERNAL_H
/* Benchmark available memcpy methods */
void xine_probe_fast_memcpy(xine_t *xine) XINE_PROTECTED;
#endif
/*
* Debug stuff
*/
/*
* profiling (unworkable in non DEBUG isn't defined)
*/
void xine_profiler_init (void) XINE_PROTECTED;
int xine_profiler_allocate_slot (const char *label) XINE_PROTECTED;
void xine_profiler_start_count (int id) XINE_PROTECTED;
void xine_profiler_stop_count (int id) XINE_PROTECTED;
void xine_profiler_print_results (void) XINE_PROTECTED;
/*
* Allocate and clean memory size_t 'size', then return the pointer
* to the allocated memory.
*/
void *xine_xmalloc(size_t size) XINE_MALLOC XINE_DEPRECATED XINE_PROTECTED;
/*
* Same as above, but memory is aligned to 'alignement'.
* **base is used to return pointer to un-aligned memory, use
* this to free the mem chunk
*/
void *xine_xmalloc_aligned(size_t alignment, size_t size, void **base) XINE_PROTECTED;
/*
* Get user home directory.
*/
const char *xine_get_homedir(void) XINE_PROTECTED;
#if defined(WIN32) || defined(__CYGWIN__)
/*
* Get other xine directories.
*/
const char *xine_get_pluginroot(void) XINE_PROTECTED;
const char *xine_get_plugindir(void) XINE_PROTECTED;
const char *xine_get_fontdir(void) XINE_PROTECTED;
const char *xine_get_localedir(void) XINE_PROTECTED;
#endif
/*
* Clean a string (remove spaces and '=' at the begin,
* and '\n', '\r' and spaces at the end.
*/
char *xine_chomp (char *str) XINE_PROTECTED;
/*
* A thread-safe usecond sleep
*/
void xine_usec_sleep(unsigned usec) XINE_PROTECTED;
/*
* Some string functions
*/
void xine_strdupa(char *dest, char *src) XINE_PROTECTED XINE_DEPRECATED;
#define xine_strdupa(d, s) do { \
(d) = NULL; \
if((s) != NULL) { \
(d) = (char *) alloca(strlen((s)) + 1); \
strcpy((d), (s)); \
} \
} while(0)
/* compatibility macros */
#define xine_strpbrk(S, ACCEPT) strpbrk((S), (ACCEPT))
#define xine_strsep(STRINGP, DELIM) strsep((STRINGP), (DELIM))
#define xine_setenv(NAME, VAL, XX) setenv((NAME), (VAL), (XX))
/**
* append to a string, reallocating
* normally, updates & returns *dest
* on error, *dest is unchanged & NULL is returned.
*/
char *xine_strcat_realloc (char **dest, char *append) XINE_PROTECTED;
/**
* asprintf wrapper
* allocate a string large enough to hold the output, and return a pointer to
* it. This pointer should be passed to free when it is no longer needed.
* return NULL on error.
*/
char *_x_asprintf(const char *format, ...) XINE_PROTECTED XINE_MALLOC XINE_FORMAT_PRINTF(1, 2);
/**
* opens a file, ensuring that the descriptor will be closed
* automatically after a fork/execute.
*/
int xine_open_cloexec(const char *name, int flags) XINE_PROTECTED;
/**
* creates a file, ensuring that the descriptor will be closed
* automatically after a fork/execute.
*/
int xine_create_cloexec(const char *name, int flags, mode_t mode) XINE_PROTECTED;
/**
* creates a socket, ensuring that the descriptor will be closed
* automatically after a fork/execute.
*/
int xine_socket_cloexec(int domain, int type, int protocol) XINE_PROTECTED;
/*
* Color Conversion Utility Functions
* The following data structures and functions facilitate the conversion
* of RGB images to packed YUV (YUY2) images. There are also functions to
* convert from YUV9 -> YV12. All of the meaty details are written in
* color.c.
*/
typedef struct yuv_planes_s {
unsigned char *y;
unsigned char *u;
unsigned char *v;
unsigned int row_width; /* frame width */
unsigned int row_count; /* frame height */
} yuv_planes_t;
void init_yuv_conversion(void) XINE_PROTECTED;
void init_yuv_planes(yuv_planes_t *yuv_planes, int width, int height) XINE_PROTECTED;
void free_yuv_planes(yuv_planes_t *yuv_planes) XINE_PROTECTED;
extern void (*yuv444_to_yuy2)
(const yuv_planes_t *yuv_planes, unsigned char *yuy2_map, int pitch) XINE_PROTECTED;
extern void (*yuv9_to_yv12)
(const unsigned char *y_src, int y_src_pitch, unsigned char *y_dest, int y_dest_pitch,
const unsigned char *u_src, int u_src_pitch, unsigned char *u_dest, int u_dest_pitch,
const unsigned char *v_src, int v_src_pitch, unsigned char *v_dest, int v_dest_pitch,
int width, int height) XINE_PROTECTED;
extern void (*yuv411_to_yv12)
(const unsigned char *y_src, int y_src_pitch, unsigned char *y_dest, int y_dest_pitch,
const unsigned char *u_src, int u_src_pitch, unsigned char *u_dest, int u_dest_pitch,
const unsigned char *v_src, int v_src_pitch, unsigned char *v_dest, int v_dest_pitch,
int width, int height) XINE_PROTECTED;
extern void (*yv12_to_yuy2)
(const unsigned char *y_src, int y_src_pitch,
const unsigned char *u_src, int u_src_pitch,
const unsigned char *v_src, int v_src_pitch,
unsigned char *yuy2_map, int yuy2_pitch,
int width, int height, int progressive) XINE_PROTECTED;
extern void (*yuy2_to_yv12)
(const unsigned char *yuy2_map, int yuy2_pitch,
unsigned char *y_dst, int y_dst_pitch,
unsigned char *u_dst, int u_dst_pitch,
unsigned char *v_dst, int v_dst_pitch,
int width, int height) XINE_PROTECTED;
#define SCALEFACTOR 65536
#define CENTERSAMPLE 128
/* These conversions are normalised for the MPEG Y'CbCr colourspace.
* (Yes, we know that we call it YUV elsewhere.)
*/
#define COMPUTE_Y(r, g, b) \
(unsigned char) \
((y_r_table[r] + y_g_table[g] + y_b_table[b]) / SCALEFACTOR)
#define COMPUTE_U(r, g, b) \
(unsigned char) \
((u_r_table[r] + u_g_table[g] + u_b_table[b]) / SCALEFACTOR + CENTERSAMPLE)
#define COMPUTE_V(r, g, b) \
(unsigned char) \
((v_r_table[r] + v_g_table[g] + v_b_table[b]) / SCALEFACTOR + CENTERSAMPLE)
#define UNPACK_BGR15(packed_pixel, r, g, b) \
b = (packed_pixel & 0x7C00) >> 7; \
g = (packed_pixel & 0x03E0) >> 2; \
r = (packed_pixel & 0x001F) << 3;
#define UNPACK_BGR16(packed_pixel, r, g, b) \
b = (packed_pixel & 0xF800) >> 8; \
g = (packed_pixel & 0x07E0) >> 3; \
r = (packed_pixel & 0x001F) << 3;
#define UNPACK_RGB15(packed_pixel, r, g, b) \
r = (packed_pixel & 0x7C00) >> 7; \
g = (packed_pixel & 0x03E0) >> 2; \
b = (packed_pixel & 0x001F) << 3;
#define UNPACK_RGB16(packed_pixel, r, g, b) \
r = (packed_pixel & 0xF800) >> 8; \
g = (packed_pixel & 0x07E0) >> 3; \
b = (packed_pixel & 0x001F) << 3;
extern int y_r_table[256] XINE_PROTECTED;
extern int y_g_table[256] XINE_PROTECTED;
extern int y_b_table[256] XINE_PROTECTED;
extern int u_r_table[256] XINE_PROTECTED;
extern int u_g_table[256] XINE_PROTECTED;
extern int u_b_table[256] XINE_PROTECTED;
extern int v_r_table[256] XINE_PROTECTED;
extern int v_g_table[256] XINE_PROTECTED;
extern int v_b_table[256] XINE_PROTECTED;
/* frame copying functions */
extern void yv12_to_yv12
(const unsigned char *y_src, int y_src_pitch, unsigned char *y_dst, int y_dst_pitch,
const unsigned char *u_src, int u_src_pitch, unsigned char *u_dst, int u_dst_pitch,
const unsigned char *v_src, int v_src_pitch, unsigned char *v_dst, int v_dst_pitch,
int width, int height) XINE_PROTECTED;
extern void yuy2_to_yuy2
(const unsigned char *src, int src_pitch,
unsigned char *dst, int dst_pitch,
int width, int height) XINE_PROTECTED;
/* print a hexdump of the given data */
void xine_hexdump (const char *buf, int length) XINE_PROTECTED;
/*
* Optimization macros for conditions
* Taken from the FIASCO L4 microkernel sources
*/
#if !defined(__GNUC__) || __GNUC__ < 3
# define EXPECT_TRUE(x) (x)
# define EXPECT_FALSE(x) (x)
#else
# define EXPECT_TRUE(x) __builtin_expect((x),1)
# define EXPECT_FALSE(x) __builtin_expect((x),0)
#endif
#ifdef NDEBUG
#define _x_assert(exp) \
do { \
if (!(exp)) \
fprintf(stderr, "assert: %s:%d: %s: Assertion `%s' failed.\n", \
__FILE__, __LINE__, __XINE_FUNCTION__, #exp); \
} while(0)
#else
#define _x_assert(exp) \
do { \
if (!(exp)) { \
fprintf(stderr, "assert: %s:%d: %s: Assertion `%s' failed.\n", \
__FILE__, __LINE__, __XINE_FUNCTION__, #exp); \
abort(); \
} \
} while(0)
#endif
#define _x_abort() \
do { \
fprintf(stderr, "abort: %s:%d: %s: Aborting.\n", \
__FILE__, __LINE__, __XINE_FUNCTION__); \
abort(); \
} while(0)
/****** logging with xine **********************************/
#ifndef LOG_MODULE
#define LOG_MODULE __FILE__
#endif /* LOG_MODULE */
#define LOG_MODULE_STRING printf("%s: ", LOG_MODULE );
#ifdef LOG_VERBOSE
#define LONG_LOG_MODULE_STRING \
printf("%s: (%s:%d) ", LOG_MODULE, __XINE_FUNCTION__, __LINE__ );
#else
#define LONG_LOG_MODULE_STRING LOG_MODULE_STRING
#endif /* LOG_VERBOSE */
#ifdef LOG
#ifdef __GNUC__
#define lprintf(fmt, args...) \
do { \
LONG_LOG_MODULE_STRING \
printf(fmt, ##args); \
fflush(stdout); \
} while(0)
#else /* __GNUC__ */
#ifdef _MSC_VER
#define lprintf(fmtargs) \
do { \
LONG_LOG_MODULE_STRING \
printf("%s", fmtargs); \
fflush(stdout); \
} while(0)
#else /* _MSC_VER */
#define lprintf(...) \
do { \
LONG_LOG_MODULE_STRING \
printf(__VA_ARGS__); \
fflush(stdout); \
} while(0)
#endif /* _MSC_VER */
#endif /* __GNUC__ */
#else /* LOG */
#ifdef __GNUC__
#define lprintf(fmt, args...) do {} while(0)
#else
#ifdef _MSC_VER
void __inline lprintf(const char * fmt, ...) {}
#else
#define lprintf(...) do {} while(0)
#endif /* _MSC_VER */
#endif /* __GNUC__ */
#endif /* LOG */
#ifdef __GNUC__
#define llprintf(cat, fmt, args...) \
do{ \
if(cat){ \
LONG_LOG_MODULE_STRING \
printf( fmt, ##args ); \
} \
}while(0)
#else
#ifdef _MSC_VER
#define llprintf(cat, fmtargs) \
do{ \
if(cat){ \
LONG_LOG_MODULE_STRING \
printf( "%s", fmtargs ); \
} \
}while(0)
#else
#define llprintf(cat, ...) \
do{ \
if(cat){ \
LONG_LOG_MODULE_STRING \
printf( __VA_ARGS__ ); \
} \
}while(0)
#endif /* _MSC_VER */
#endif /* __GNUC__ */
#ifdef __GNUC__
#define xprintf(xine, verbose, fmt, args...) \
do { \
if((xine) && (xine)->verbosity >= verbose){ \
xine_log(xine, XINE_LOG_TRACE, fmt, ##args); \
} \
} while(0)
#else
#ifdef _MSC_VER
void xine_xprintf(xine_t *xine, int verbose, const char *fmt, ...);
#define xprintf xine_xprintf
#else
#define xprintf(xine, verbose, ...) \
do { \
if((xine) && (xine)->verbosity >= verbose){ \
xine_log(xine, XINE_LOG_TRACE, __VA_ARGS__); \
} \
} while(0)
#endif /* _MSC_VER */
#endif /* __GNUC__ */
/* time measuring macros for profiling tasks */
#ifdef DEBUG
# define XINE_PROFILE(function) \
do { \
struct timeval current_time; \
double dtime; \
gettimeofday(&current_time, NULL); \
dtime = -(current_time.tv_sec + (current_time.tv_usec / 1000000.0)); \
function; \
gettimeofday(&current_time, NULL); \
dtime += current_time.tv_sec + (current_time.tv_usec / 1000000.0); \
printf("%s: (%s:%d) took %lf seconds\n", \
LOG_MODULE, __XINE_FUNCTION__, __LINE__, dtime); \
} while(0)
# define XINE_PROFILE_ACCUMULATE(function) \
do { \
struct timeval current_time; \
static double dtime = 0; \
gettimeofday(&current_time, NULL); \
dtime -= current_time.tv_sec + (current_time.tv_usec / 1000000.0); \
function; \
gettimeofday(&current_time, NULL); \
dtime += current_time.tv_sec + (current_time.tv_usec / 1000000.0); \
printf("%s: (%s:%d) took %lf seconds\n", \
LOG_MODULE, __XINE_FUNCTION__, __LINE__, dtime); \
} while(0)
#else
# define XINE_PROFILE(function) function
# define XINE_PROFILE_ACCUMULATE(function) function
#endif /* DEBUG */
/**
* get encoding of current locale
*/
char *xine_get_system_encoding(void) XINE_MALLOC XINE_PROTECTED;
/*
* guess default encoding for the subtitles
*/
const char *xine_guess_spu_encoding(void) XINE_PROTECTED;
/*
* use the best clock reference (API compatible with gettimeofday)
* note: it will be a monotonic clock, if available.
*/
int xine_monotonic_clock(struct timeval *tv, struct timezone *tz) XINE_PROTECTED;
/* don't harm following code */
#ifdef extern
# undef extern
#endif
#ifdef __cplusplus
}
#endif
#endif

Get latest updates about Open Source Projects, Conferences and News.

Sign up for the SourceForge newsletter:

JavaScript is required for this form.





No, thanks