diff options
Diffstat (limited to 'src')
30 files changed, 1831 insertions, 94 deletions
diff --git a/src/libmpeg2new/Makefile.am b/src/libmpeg2new/Makefile.am index a7d422bd5..03dae6cba 100644 --- a/src/libmpeg2new/Makefile.am +++ b/src/libmpeg2new/Makefile.am @@ -2,7 +2,7 @@ include $(top_srcdir)/misc/Makefile.common AM_CFLAGS = $(LIBMPEG2_CFLAGS) -EXTRA_DIST = idct_mlib.c idct_mlib.h motion_comp_mlib.c +SUBDIRS = libmpeg2 libdir = $(XINE_PLUGINDIR) @@ -11,6 +11,6 @@ lib_LTLIBRARIES = xineplug_decode_mpeg2.la xineplug_decode_mpeg2_la_SOURCES = \ xine_decoder.c -xineplug_decode_mpeg2_la_LIBADD = $(XINE_LIB) /usr/local/lib/libmpeg2.la +xineplug_decode_mpeg2_la_LIBADD = $(XINE_LIB) ./libmpeg2/libmpeg2.la xineplug_decode_mpeg2_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@ diff --git a/src/libmpeg2new/include/Makefile.am b/src/libmpeg2new/include/Makefile.am new file mode 100644 index 000000000..56c98512d --- /dev/null +++ b/src/libmpeg2new/include/Makefile.am @@ -0,0 +1,3 @@ +pkginclude_HEADERS = mpeg2.h convert.h + +EXTRA_DIST = video_out.h mmx.h alpha_asm.h attributes.h tendra.h diff --git a/src/libmpeg2new/include/alpha_asm.h b/src/libmpeg2new/include/alpha_asm.h new file mode 100644 index 000000000..bf1081f24 --- /dev/null +++ b/src/libmpeg2new/include/alpha_asm.h @@ -0,0 +1,181 @@ +/* + * Alpha assembly macros + * Copyright (c) 2002-2003 Falk Hueffner <falk@debian.org> + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * See http://libmpeg2.sourceforge.net/ for updates. + * + * mpeg2dec 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. + * + * mpeg2dec 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef ALPHA_ASM_H +#define ALPHA_ASM_H + +#include <inttypes.h> + +#if defined __GNUC__ +# define GNUC_PREREQ(maj, min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#else +# define GNUC_PREREQ(maj, min) 0 +#endif + +#define AMASK_BWX (1 << 0) +#define AMASK_FIX (1 << 1) +#define AMASK_CIX (1 << 2) +#define AMASK_MVI (1 << 8) + +#ifdef __alpha_bwx__ +# define HAVE_BWX() 1 +#else +# define HAVE_BWX() (amask(AMASK_BWX) == 0) +#endif +#ifdef __alpha_fix__ +# define HAVE_FIX() 1 +#else +# define HAVE_FIX() (amask(AMASK_FIX) == 0) +#endif +#ifdef __alpha_max__ +# define HAVE_MVI() 1 +#else +# define HAVE_MVI() (amask(AMASK_MVI) == 0) +#endif +#ifdef __alpha_cix__ +# define HAVE_CIX() 1 +#else +# define HAVE_CIX() (amask(AMASK_CIX) == 0) +#endif + +inline static uint64_t BYTE_VEC(uint64_t x) +{ + x |= x << 8; + x |= x << 16; + x |= x << 32; + return x; +} +inline static uint64_t WORD_VEC(uint64_t x) +{ + x |= x << 16; + x |= x << 32; + return x; +} + +#define ldq(p) (*(const uint64_t *) (p)) +#define ldl(p) (*(const int32_t *) (p)) +#define stl(l, p) do { *(uint32_t *) (p) = (l); } while (0) +#define stq(l, p) do { *(uint64_t *) (p) = (l); } while (0) +#define sextw(x) ((int16_t) (x)) + +#ifdef __GNUC__ +struct unaligned_long { uint64_t l; } __attribute__((packed)); +#define ldq_u(p) (*(const uint64_t *) (((uint64_t) (p)) & ~7ul)) +#define uldq(a) (((const struct unaligned_long *) (a))->l) + +#if GNUC_PREREQ(3,3) +#define prefetch(p) __builtin_prefetch((p), 0, 1) +#define prefetch_en(p) __builtin_prefetch((p), 0, 0) +#define prefetch_m(p) __builtin_prefetch((p), 1, 1) +#define prefetch_men(p) __builtin_prefetch((p), 1, 0) +#define cmpbge __builtin_alpha_cmpbge +/* Avoid warnings. */ +#define extql(a, b) __builtin_alpha_extql(a, (uint64_t) (b)) +#define extwl(a, b) __builtin_alpha_extwl(a, (uint64_t) (b)) +#define extqh(a, b) __builtin_alpha_extqh(a, (uint64_t) (b)) +#define zap __builtin_alpha_zap +#define zapnot __builtin_alpha_zapnot +#define amask __builtin_alpha_amask +#define implver __builtin_alpha_implver +#define rpcc __builtin_alpha_rpcc +#else +#define prefetch(p) asm volatile("ldl $31,%0" : : "m"(*(const char *) (p)) : "memory") +#define prefetch_en(p) asm volatile("ldq $31,%0" : : "m"(*(const char *) (p)) : "memory") +#define prefetch_m(p) asm volatile("lds $f31,%0" : : "m"(*(const char *) (p)) : "memory") +#define prefetch_men(p) asm volatile("ldt $f31,%0" : : "m"(*(const char *) (p)) : "memory") +#define cmpbge(a, b) ({ uint64_t __r; asm ("cmpbge %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) +#define extql(a, b) ({ uint64_t __r; asm ("extql %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) +#define extwl(a, b) ({ uint64_t __r; asm ("extwl %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) +#define extqh(a, b) ({ uint64_t __r; asm ("extqh %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) +#define zap(a, b) ({ uint64_t __r; asm ("zap %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) +#define zapnot(a, b) ({ uint64_t __r; asm ("zapnot %r1,%2,%0" : "=r" (__r) : "rJ" (a), "rI" (b)); __r; }) +#define amask(a) ({ uint64_t __r; asm ("amask %1,%0" : "=r" (__r) : "rI" (a)); __r; }) +#define implver() ({ uint64_t __r; asm ("implver %0" : "=r" (__r)); __r; }) +#define rpcc() ({ uint64_t __r; asm volatile ("rpcc %0" : "=r" (__r)); __r; }) +#endif +#define wh64(p) asm volatile("wh64 (%0)" : : "r"(p) : "memory") + +#if GNUC_PREREQ(3,3) && defined(__alpha_max__) +#define minub8 __builtin_alpha_minub8 +#define minsb8 __builtin_alpha_minsb8 +#define minuw4 __builtin_alpha_minuw4 +#define minsw4 __builtin_alpha_minsw4 +#define maxub8 __builtin_alpha_maxub8 +#define maxsb8 __builtin_alpha_maxsb8 +#define maxuw4 __builtin_alpha_maxuw4 +#define maxsw4 __builtin_alpha_maxsw4 +#define perr __builtin_alpha_perr +#define pklb __builtin_alpha_pklb +#define pkwb __builtin_alpha_pkwb +#define unpkbl __builtin_alpha_unpkbl +#define unpkbw __builtin_alpha_unpkbw +#else +#define minub8(a, b) ({ uint64_t __r; asm (".arch ev6; minub8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) +#define minsb8(a, b) ({ uint64_t __r; asm (".arch ev6; minsb8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) +#define minuw4(a, b) ({ uint64_t __r; asm (".arch ev6; minuw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) +#define minsw4(a, b) ({ uint64_t __r; asm (".arch ev6; minsw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) +#define maxub8(a, b) ({ uint64_t __r; asm (".arch ev6; maxub8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) +#define maxsb8(a, b) ({ uint64_t __r; asm (".arch ev6; maxsb8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) +#define maxuw4(a, b) ({ uint64_t __r; asm (".arch ev6; maxuw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) +#define maxsw4(a, b) ({ uint64_t __r; asm (".arch ev6; maxsw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) +#define perr(a, b) ({ uint64_t __r; asm (".arch ev6; perr %r1,%r2,%0" : "=r" (__r) : "%rJ" (a), "rJ" (b)); __r; }) +#define pklb(a) ({ uint64_t __r; asm (".arch ev6; pklb %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) +#define pkwb(a) ({ uint64_t __r; asm (".arch ev6; pkwb %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) +#define unpkbl(a) ({ uint64_t __r; asm (".arch ev6; unpkbl %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) +#define unpkbw(a) ({ uint64_t __r; asm (".arch ev6; unpkbw %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) +#endif + +#elif defined(__DECC) /* Digital/Compaq/hp "ccc" compiler */ + +#include <c_asm.h> +#define ldq_u(a) asm ("ldq_u %v0,0(%a0)", a) +#define uldq(a) (*(const __unaligned uint64_t *) (a)) +#define cmpbge(a, b) asm ("cmpbge %a0,%a1,%v0", a, b) +#define extql(a, b) asm ("extql %a0,%a1,%v0", a, b) +#define extwl(a, b) asm ("extwl %a0,%a1,%v0", a, b) +#define extqh(a, b) asm ("extqh %a0,%a1,%v0", a, b) +#define zap(a, b) asm ("zap %a0,%a1,%v0", a, b) +#define zapnot(a, b) asm ("zapnot %a0,%a1,%v0", a, b) +#define amask(a) asm ("amask %a0,%v0", a) +#define implver() asm ("implver %v0") +#define rpcc() asm ("rpcc %v0") +#define minub8(a, b) asm ("minub8 %a0,%a1,%v0", a, b) +#define minsb8(a, b) asm ("minsb8 %a0,%a1,%v0", a, b) +#define minuw4(a, b) asm ("minuw4 %a0,%a1,%v0", a, b) +#define minsw4(a, b) asm ("minsw4 %a0,%a1,%v0", a, b) +#define maxub8(a, b) asm ("maxub8 %a0,%a1,%v0", a, b) +#define maxsb8(a, b) asm ("maxsb8 %a0,%a1,%v0", a, b) +#define maxuw4(a, b) asm ("maxuw4 %a0,%a1,%v0", a, b) +#define maxsw4(a, b) asm ("maxsw4 %a0,%a1,%v0", a, b) +#define perr(a, b) asm ("perr %a0,%a1,%v0", a, b) +#define pklb(a) asm ("pklb %a0,%v0", a) +#define pkwb(a) asm ("pkwb %a0,%v0", a) +#define unpkbl(a) asm ("unpkbl %a0,%v0", a) +#define unpkbw(a) asm ("unpkbw %a0,%v0", a) +#define wh64(a) asm ("wh64 %a0", a) + +#else +#error "Unknown compiler!" +#endif + +#endif /* ALPHA_ASM_H */ diff --git a/src/libmpeg2new/include/attributes.h b/src/libmpeg2new/include/attributes.h new file mode 100644 index 000000000..eefbc0dd1 --- /dev/null +++ b/src/libmpeg2new/include/attributes.h @@ -0,0 +1,37 @@ +/* + * attributes.h + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> + * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * See http://libmpeg2.sourceforge.net/ for updates. + * + * mpeg2dec 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. + * + * mpeg2dec 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* use gcc attribs to align critical data structures */ +#ifdef ATTRIBUTE_ALIGNED_MAX +#define ATTR_ALIGN(align) __attribute__ ((__aligned__ ((ATTRIBUTE_ALIGNED_MAX < align) ? ATTRIBUTE_ALIGNED_MAX : align))) +#else +#define ATTR_ALIGN(align) +#endif + +#ifdef HAVE_BUILTIN_EXPECT +#define likely(x) __builtin_expect ((x) != 0, 1) +#define unlikely(x) __builtin_expect ((x) != 0, 0) +#else +#define likely(x) (x) +#define unlikely(x) (x) +#endif diff --git a/src/libmpeg2new/include/config.h b/src/libmpeg2new/include/config.h new file mode 100644 index 000000000..2060723d2 --- /dev/null +++ b/src/libmpeg2new/include/config.h @@ -0,0 +1,161 @@ +/* include/config.h. Generated by configure. */ +/* include/config.h.in. Generated from configure.in by autoheader. */ + +/* autodetect accelerations */ +#define ACCEL_DETECT + +/* alpha architecture */ +/* #undef ARCH_ALPHA */ + +/* ppc architecture */ +/* #undef ARCH_PPC */ + +/* x86 architecture */ +#define ARCH_X86 + +/* maximum supported data alignment */ +#define ATTRIBUTE_ALIGNED_MAX 64 + +/* debug mode configuration */ +/* #undef DEBUG */ + +/* Define to 1 if you have the <altivec.h> header file. */ +/* #undef HAVE_ALTIVEC_H */ + +/* Define if you have the `__builtin_expect' function. */ +#define HAVE_BUILTIN_EXPECT + +/* Define to 1 if you have the <ddraw.h> header file. */ +/* #undef HAVE_DDRAW_H */ + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#define HAVE_DLFCN_H 1 + +/* Define to 1 if you have the `ftime' function. */ +#define HAVE_FTIME 1 + +/* Define to 1 if you have the `gettimeofday' function. */ +#define HAVE_GETTIMEOFDAY 1 + +/* Define to 1 if you have the <inttypes.h> header file. */ +/* #undef HAVE_INTTYPES_H */ + +/* Define to 1 if you have the <io.h> header file. */ +/* #undef HAVE_IO_H */ + +/* Define to 1 if you have the `memalign' function. */ +#define HAVE_MEMALIGN 1 + +/* Define to 1 if you have the <memory.h> header file. */ +/* #undef HAVE_MEMORY_H */ + +/* Define to 1 if you have the <stdint.h> header file. */ +/* #undef HAVE_STDINT_H */ + +/* Define to 1 if you have the <stdlib.h> header file. */ +/* #undef HAVE_STDLIB_H */ + +/* Define to 1 if you have the <strings.h> header file. */ +/* #undef HAVE_STRINGS_H */ + +/* Define to 1 if you have the <string.h> header file. */ +/* #undef HAVE_STRING_H */ + +/* Define to 1 if the system has the type `struct timeval'. */ +#define HAVE_STRUCT_TIMEVAL 1 + +/* Define to 1 if you have the <sys/stat.h> header file. */ +/* #undef HAVE_SYS_STAT_H */ + +/* Define to 1 if you have the <sys/timeb.h> header file. */ +#define HAVE_SYS_TIMEB_H 1 + +/* Define to 1 if you have the <sys/time.h> header file. */ +#define HAVE_SYS_TIME_H 1 + +/* Define to 1 if you have the <sys/types.h> header file. */ +/* #undef HAVE_SYS_TYPES_H */ + +/* Define to 1 if you have the <time.h> header file. */ +#define HAVE_TIME_H 1 + +/* Define to 1 if you have the <unistd.h> header file. */ +/* #undef HAVE_UNISTD_H */ + +/* libmpeg2 mediaLib support */ +/* #undef LIBMPEG2_MLIB */ + +/* libvo DirectX support */ +/* #undef LIBVO_DX */ + +/* libvo mediaLib support */ +/* #undef LIBVO_MLIB */ + +/* libvo SDL support */ +#define LIBVO_SDL + +/* libvo X11 support */ +#define LIBVO_X11 + +/* libvo Xv support */ +#define LIBVO_XV + +/* mpeg2dec profiling */ +/* #undef MPEG2DEC_GPROF */ + +/* Name of package */ +#define PACKAGE "mpeg2dec" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "" + +/* Define as the return type of signal handlers (`int' or `void'). */ +#define RETSIGTYPE void + +/* The size of a `char', as computed by sizeof. */ +/* #undef SIZEOF_CHAR */ + +/* The size of a `int', as computed by sizeof. */ +/* #undef SIZEOF_INT */ + +/* The size of a `short', as computed by sizeof. */ +/* #undef SIZEOF_SHORT */ + +/* Define to 1 if you have the ANSI C header files. */ +/* #undef STDC_HEADERS */ + +/* Version number of package */ +#define VERSION "0.3.2-cvs" + +/* Define to 1 if your processor stores words with the most significant byte + first (like Motorola and SPARC, unlike Intel and VAX). */ +/* #undef WORDS_BIGENDIAN */ + +/* Define to 1 if the X Window System is missing or not being used. */ +/* #undef X_DISPLAY_MISSING */ + +/* Define to empty if `const' does not conform to ANSI C. */ +/* #undef const */ + +/* Define as `__inline' if that's what the C compiler calls it, or to nothing + if it is not supported. */ +#define inline __attribute__ ((__always_inline__)) + +/* Define as `__restrict' if that's what the C compiler calls it, or to + nothing if it is not supported. */ +#define restrict __restrict__ + +/* Define to `unsigned' if <sys/types.h> does not define. */ +/* #undef size_t */ diff --git a/src/libmpeg2new/include/config.h.in b/src/libmpeg2new/include/config.h.in new file mode 100644 index 000000000..365ab931c --- /dev/null +++ b/src/libmpeg2new/include/config.h.in @@ -0,0 +1,160 @@ +/* include/config.h.in. Generated from configure.in by autoheader. */ + +/* autodetect accelerations */ +#undef ACCEL_DETECT + +/* alpha architecture */ +#undef ARCH_ALPHA + +/* ppc architecture */ +#undef ARCH_PPC + +/* x86 architecture */ +#undef ARCH_X86 + +/* maximum supported data alignment */ +#undef ATTRIBUTE_ALIGNED_MAX + +/* debug mode configuration */ +#undef DEBUG + +/* Define to 1 if you have the <altivec.h> header file. */ +#undef HAVE_ALTIVEC_H + +/* Define if you have the `__builtin_expect' function. */ +#undef HAVE_BUILTIN_EXPECT + +/* Define to 1 if you have the <ddraw.h> header file. */ +#undef HAVE_DDRAW_H + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#undef HAVE_DLFCN_H + +/* Define to 1 if you have the `ftime' function. */ +#undef HAVE_FTIME + +/* Define to 1 if you have the `gettimeofday' function. */ +#undef HAVE_GETTIMEOFDAY + +/* Define to 1 if you have the <inttypes.h> header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the <io.h> header file. */ +#undef HAVE_IO_H + +/* Define to 1 if you have the `memalign' function. */ +#undef HAVE_MEMALIGN + +/* Define to 1 if you have the <memory.h> header file. */ +#undef HAVE_MEMORY_H + +/* Define to 1 if you have the <stdint.h> header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the <stdlib.h> header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the <strings.h> header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the <string.h> header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if the system has the type `struct timeval'. */ +#undef HAVE_STRUCT_TIMEVAL + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the <sys/timeb.h> header file. */ +#undef HAVE_SYS_TIMEB_H + +/* Define to 1 if you have the <sys/time.h> header file. */ +#undef HAVE_SYS_TIME_H + +/* Define to 1 if you have the <sys/types.h> header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the <time.h> header file. */ +#undef HAVE_TIME_H + +/* Define to 1 if you have the <unistd.h> header file. */ +#undef HAVE_UNISTD_H + +/* libmpeg2 mediaLib support */ +#undef LIBMPEG2_MLIB + +/* libvo DirectX support */ +#undef LIBVO_DX + +/* libvo mediaLib support */ +#undef LIBVO_MLIB + +/* libvo SDL support */ +#undef LIBVO_SDL + +/* libvo X11 support */ +#undef LIBVO_X11 + +/* libvo Xv support */ +#undef LIBVO_XV + +/* mpeg2dec profiling */ +#undef MPEG2DEC_GPROF + +/* Name of package */ +#undef PACKAGE + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define as the return type of signal handlers (`int' or `void'). */ +#undef RETSIGTYPE + +/* The size of a `char', as computed by sizeof. */ +#undef SIZEOF_CHAR + +/* The size of a `int', as computed by sizeof. */ +#undef SIZEOF_INT + +/* The size of a `short', as computed by sizeof. */ +#undef SIZEOF_SHORT + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Version number of package */ +#undef VERSION + +/* Define to 1 if your processor stores words with the most significant byte + first (like Motorola and SPARC, unlike Intel and VAX). */ +#undef WORDS_BIGENDIAN + +/* Define to 1 if the X Window System is missing or not being used. */ +#undef X_DISPLAY_MISSING + +/* Define to empty if `const' does not conform to ANSI C. */ +#undef const + +/* Define as `__inline' if that's what the C compiler calls it, or to nothing + if it is not supported. */ +#undef inline + +/* Define as `__restrict' if that's what the C compiler calls it, or to + nothing if it is not supported. */ +#undef restrict + +/* Define to `unsigned' if <sys/types.h> does not define. */ +#undef size_t diff --git a/src/libmpeg2new/include/convert.h b/src/libmpeg2new/include/convert.h new file mode 100644 index 000000000..8e4154d19 --- /dev/null +++ b/src/libmpeg2new/include/convert.h @@ -0,0 +1,56 @@ +/* + * convert.h + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> + * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * See http://libmpeg2.sourceforge.net/ for updates. + * + * mpeg2dec 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. + * + * mpeg2dec 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef CONVERT_H +#define CONVERT_H + +#define CONVERT_FRAME 0 +#define CONVERT_TOP_FIELD 1 +#define CONVERT_BOTTOM_FIELD 2 +#define CONVERT_BOTH_FIELDS 3 + +typedef struct convert_init_s { + void * id; + int id_size; + int buf_size[3]; + void (* start) (void * id, uint8_t * const * dest, int flags); + void (* copy) (void * id, uint8_t * const * src, unsigned int v_offset); +} convert_init_t; + +typedef void convert_t (int width, int height, uint32_t accel, void * arg, + convert_init_t * result); + +convert_t convert_rgb32; +convert_t convert_rgb24; +convert_t convert_rgb16; +convert_t convert_rgb15; +convert_t convert_bgr32; +convert_t convert_bgr24; +convert_t convert_bgr16; +convert_t convert_bgr15; + +#define CONVERT_RGB 0 +#define CONVERT_BGR 1 +convert_t * convert_rgb (int order, int bpp); + +#endif /* CONVERT_H */ diff --git a/src/libmpeg2new/include/mmx.h b/src/libmpeg2new/include/mmx.h new file mode 100644 index 000000000..08b4d4776 --- /dev/null +++ b/src/libmpeg2new/include/mmx.h @@ -0,0 +1,263 @@ +/* + * mmx.h + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> + * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * See http://libmpeg2.sourceforge.net/ for updates. + * + * mpeg2dec 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. + * + * mpeg2dec 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* + * 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) + */ + +typedef union { + long long q; /* Quadword (64-bit) value */ + unsigned long long uq; /* Unsigned Quadword */ + int d[2]; /* 2 Doubleword (32-bit) values */ + unsigned int ud[2]; /* 2 Unsigned Doubleword */ + short w[4]; /* 4 Word (16-bit) values */ + unsigned short uw[4]; /* 4 Unsigned Word */ + char b[8]; /* 8 Byte (8-bit) values */ + unsigned char ub[8]; /* 8 Unsigned Byte */ + float s[2]; /* Single-precision (32-bit) value */ +} ATTR_ALIGN(8) mmx_t; /* On an 8-byte (64-bit) boundary */ + + +#define mmx_i2r(op,imm,reg) \ + __asm__ __volatile__ (#op " %0, %%" #reg \ + : /* nothing */ \ + : "i" (imm) ) + +#define mmx_m2r(op,mem,reg) \ + __asm__ __volatile__ (#op " %0, %%" #reg \ + : /* nothing */ \ + : "m" (mem)) + +#define mmx_r2m(op,reg,mem) \ + __asm__ __volatile__ (#op " %%" #reg ", %0" \ + : "=m" (mem) \ + : /* nothing */ ) + +#define mmx_r2r(op,regs,regd) \ + __asm__ __volatile__ (#op " %" #regs ", %" #regd) + + +#define emms() __asm__ __volatile__ ("emms") + +#define movd_m2r(var,reg) mmx_m2r (movd, var, reg) +#define movd_r2m(reg,var) mmx_r2m (movd, reg, var) +#define movd_v2r(var,reg) __asm__ __volatile__ ("movd %0, %%" #reg \ + : /* nothing */ \ + : "rm" (var)) +#define movd_r2v(reg,var) __asm__ __volatile__ ("movd %%" #reg ", %0" \ + : "=rm" (var) \ + : /* nothing */ ) + +#define movq_m2r(var,reg) mmx_m2r (movq, var, reg) +#define movq_r2m(reg,var) mmx_r2m (movq, reg, var) +#define movq_r2r(regs,regd) mmx_r2r (movq, regs, regd) + +#define packssdw_m2r(var,reg) mmx_m2r (packssdw, var, reg) +#define packssdw_r2r(regs,regd) mmx_r2r (packssdw, regs, regd) +#define packsswb_m2r(var,reg) mmx_m2r (packsswb, var, reg) +#define packsswb_r2r(regs,regd) mmx_r2r (packsswb, regs, regd) + +#define packuswb_m2r(var,reg) mmx_m2r (packuswb, var, reg) +#define packuswb_r2r(regs,regd) mmx_r2r (packuswb, regs, regd) + +#define paddb_m2r(var,reg) mmx_m2r (paddb, var, reg) +#define paddb_r2r(regs,regd) mmx_r2r (paddb, regs, regd) +#define paddd_m2r(var,reg) mmx_m2r (paddd, var, reg) +#define paddd_r2r(regs,regd) mmx_r2r (paddd, regs, regd) +#define paddw_m2r(var,reg) mmx_m2r (paddw, var, reg) +#define paddw_r2r(regs,regd) mmx_r2r (paddw, regs, regd) + +#define paddsb_m2r(var,reg) mmx_m2r (paddsb, var, reg) +#define paddsb_r2r(regs,regd) mmx_r2r (paddsb, regs, regd) +#define paddsw_m2r(var,reg) mmx_m2r (paddsw, var, reg) +#define paddsw_r2r(regs,regd) mmx_r2r (paddsw, regs, regd) + +#define paddusb_m2r(var,reg) mmx_m2r (paddusb, var, reg) +#define paddusb_r2r(regs,regd) mmx_r2r (paddusb, regs, regd) +#define paddusw_m2r(var,reg) mmx_m2r (paddusw, var, reg) +#define paddusw_r2r(regs,regd) mmx_r2r (paddusw, regs, regd) + +#define pand_m2r(var,reg) mmx_m2r (pand, var, reg) +#define pand_r2r(regs,regd) mmx_r2r (pand, regs, regd) + +#define pandn_m2r(var,reg) mmx_m2r (pandn, var, reg) +#define pandn_r2r(regs,regd) mmx_r2r (pandn, regs, regd) + +#define pcmpeqb_m2r(var,reg) mmx_m2r (pcmpeqb, var, reg) +#define pcmpeqb_r2r(regs,regd) mmx_r2r (pcmpeqb, regs, regd) +#define pcmpeqd_m2r(var,reg) mmx_m2r (pcmpeqd, var, reg) +#define pcmpeqd_r2r(regs,regd) mmx_r2r (pcmpeqd, regs, regd) +#define pcmpeqw_m2r(var,reg) mmx_m2r (pcmpeqw, var, reg) +#define pcmpeqw_r2r(regs,regd) mmx_r2r (pcmpeqw, regs, regd) + +#define pcmpgtb_m2r(var,reg) mmx_m2r (pcmpgtb, var, reg) +#define pcmpgtb_r2r(regs,regd) mmx_r2r (pcmpgtb, regs, regd) +#define pcmpgtd_m2r(var,reg) mmx_m2r (pcmpgtd, var, reg) +#define pcmpgtd_r2r(regs,regd) mmx_r2r (pcmpgtd, regs, regd) +#define pcmpgtw_m2r(var,reg) mmx_m2r (pcmpgtw, var, reg) +#define pcmpgtw_r2r(regs,regd) mmx_r2r (pcmpgtw, regs, regd) + +#define pmaddwd_m2r(var,reg) mmx_m2r (pmaddwd, var, reg) +#define pmaddwd_r2r(regs,regd) mmx_r2r (pmaddwd, regs, regd) + +#define pmulhw_m2r(var,reg) mmx_m2r (pmulhw, var, reg) +#define pmulhw_r2r(regs,regd) mmx_r2r (pmulhw, regs, regd) + +#define pmullw_m2r(var,reg) mmx_m2r (pmullw, var, reg) +#define pmullw_r2r(regs,regd) mmx_r2r (pmullw, regs, regd) + +#define por_m2r(var,reg) mmx_m2r (por, var, reg) +#define por_r2r(regs,regd) mmx_r2r (por, regs, regd) + +#define pslld_i2r(imm,reg) mmx_i2r (pslld, imm, reg) +#define pslld_m2r(var,reg) mmx_m2r (pslld, var, reg) +#define pslld_r2r(regs,regd) mmx_r2r (pslld, regs, regd) +#define psllq_i2r(imm,reg) mmx_i2r (psllq, imm, reg) +#define psllq_m2r(var,reg) mmx_m2r (psllq, var, reg) +#define psllq_r2r(regs,regd) mmx_r2r (psllq, regs, regd) +#define psllw_i2r(imm,reg) mmx_i2r (psllw, imm, reg) +#define psllw_m2r(var,reg) mmx_m2r (psllw, var, reg) +#define psllw_r2r(regs,regd) mmx_r2r (psllw, regs, regd) + +#define psrad_i2r(imm,reg) mmx_i2r (psrad, imm, reg) +#define psrad_m2r(var,reg) mmx_m2r (psrad, var, reg) +#define psrad_r2r(regs,regd) mmx_r2r (psrad, regs, regd) +#define psraw_i2r(imm,reg) mmx_i2r (psraw, imm, reg) +#define psraw_m2r(var,reg) mmx_m2r (psraw, var, reg) +#define psraw_r2r(regs,regd) mmx_r2r (psraw, regs, regd) + +#define psrld_i2r(imm,reg) mmx_i2r (psrld, imm, reg) +#define psrld_m2r(var,reg) mmx_m2r (psrld, var, reg) +#define psrld_r2r(regs,regd) mmx_r2r (psrld, regs, regd) +#define psrlq_i2r(imm,reg) mmx_i2r (psrlq, imm, reg) +#define psrlq_m2r(var,reg) mmx_m2r (psrlq, var, reg) +#define psrlq_r2r(regs,regd) mmx_r2r (psrlq, regs, regd) +#define psrlw_i2r(imm,reg) mmx_i2r (psrlw, imm, reg) +#define psrlw_m2r(var,reg) mmx_m2r (psrlw, var, reg) +#define psrlw_r2r(regs,regd) mmx_r2r (psrlw, regs, regd) + +#define psubb_m2r(var,reg) mmx_m2r (psubb, var, reg) +#define psubb_r2r(regs,regd) mmx_r2r (psubb, regs, regd) +#define psubd_m2r(var,reg) mmx_m2r (psubd, var, reg) +#define psubd_r2r(regs,regd) mmx_r2r (psubd, regs, regd) +#define psubw_m2r(var,reg) mmx_m2r (psubw, var, reg) +#define psubw_r2r(regs,regd) mmx_r2r (psubw, regs, regd) + +#define psubsb_m2r(var,reg) mmx_m2r (psubsb, var, reg) +#define psubsb_r2r(regs,regd) mmx_r2r (psubsb, regs, regd) +#define psubsw_m2r(var,reg) mmx_m2r (psubsw, var, reg) +#define psubsw_r2r(regs,regd) mmx_r2r (psubsw, regs, regd) + +#define psubusb_m2r(var,reg) mmx_m2r (psubusb, var, reg) +#define psubusb_r2r(regs,regd) mmx_r2r (psubusb, regs, regd) +#define psubusw_m2r(var,reg) mmx_m2r (psubusw, var, reg) +#define psubusw_r2r(regs,regd) mmx_r2r (psubusw, regs, regd) + +#define punpckhbw_m2r(var,reg) mmx_m2r (punpckhbw, var, reg) +#define punpckhbw_r2r(regs,regd) mmx_r2r (punpckhbw, regs, regd) +#define punpckhdq_m2r(var,reg) mmx_m2r (punpckhdq, var, reg) +#define punpckhdq_r2r(regs,regd) mmx_r2r (punpckhdq, regs, regd) +#define punpckhwd_m2r(var,reg) mmx_m2r (punpckhwd, var, reg) +#define punpckhwd_r2r(regs,regd) mmx_r2r (punpckhwd, regs, regd) + +#define punpcklbw_m2r(var,reg) mmx_m2r (punpcklbw, var, reg) +#define punpcklbw_r2r(regs,regd) mmx_r2r (punpcklbw, regs, regd) +#define punpckldq_m2r(var,reg) mmx_m2r (punpckldq, var, reg) +#define punpckldq_r2r(regs,regd) mmx_r2r (punpckldq, regs, regd) +#define punpcklwd_m2r(var,reg) mmx_m2r (punpcklwd, var, reg) +#define punpcklwd_r2r(regs,regd) mmx_r2r (punpcklwd, regs, regd) + +#define pxor_m2r(var,reg) mmx_m2r (pxor, var, reg) +#define pxor_r2r(regs,regd) mmx_r2r (pxor, regs, regd) + + +/* 3DNOW extensions */ + +#define pavgusb_m2r(var,reg) mmx_m2r (pavgusb, var, reg) +#define pavgusb_r2r(regs,regd) mmx_r2r (pavgusb, regs, regd) + + +/* AMD MMX extensions - also available in intel SSE */ + + +#define mmx_m2ri(op,mem,reg,imm) \ + __asm__ __volatile__ (#op " %1, %0, %%" #reg \ + : /* nothing */ \ + : "m" (mem), "i" (imm)) + +#define mmx_r2ri(op,regs,regd,imm) \ + __asm__ __volatile__ (#op " %0, %%" #regs ", %%" #regd \ + : /* nothing */ \ + : "i" (imm) ) + +#define mmx_fetch(mem,hint) \ + __asm__ __volatile__ ("prefetch" #hint " %0" \ + : /* nothing */ \ + : "m" (mem)) + + +#define maskmovq(regs,maskreg) mmx_r2ri (maskmovq, regs, maskreg) + +#define movntq_r2m(mmreg,var) mmx_r2m (movntq, mmreg, var) + +#define pavgb_m2r(var,reg) mmx_m2r (pavgb, var, reg) +#define pavgb_r2r(regs,regd) mmx_r2r (pavgb, regs, regd) +#define pavgw_m2r(var,reg) mmx_m2r (pavgw, var, reg) +#define pavgw_r2r(regs,regd) mmx_r2r (pavgw, regs, regd) + +#define pextrw_r2r(mmreg,reg,imm) mmx_r2ri (pextrw, mmreg, reg, imm) + +#define pinsrw_r2r(reg,mmreg,imm) mmx_r2ri (pinsrw, reg, mmreg, imm) + +#define pmaxsw_m2r(var,reg) mmx_m2r (pmaxsw, var, reg) +#define pmaxsw_r2r(regs,regd) mmx_r2r (pmaxsw, regs, regd) + +#define pmaxub_m2r(var,reg) mmx_m2r (pmaxub, var, reg) +#define pmaxub_r2r(regs,regd) mmx_r2r (pmaxub, regs, regd) + +#define pminsw_m2r(var,reg) mmx_m2r (pminsw, var, reg) +#define pminsw_r2r(regs,regd) mmx_r2r (pminsw, regs, regd) + +#define pminub_m2r(var,reg) mmx_m2r (pminub, var, reg) +#define pminub_r2r(regs,regd) mmx_r2r (pminub, regs, regd) + +#define pmovmskb(mmreg,reg) \ + __asm__ __volatile__ ("movmskps %" #mmreg ", %" #reg) + +#define pmulhuw_m2r(var,reg) mmx_m2r (pmulhuw, var, reg) +#define pmulhuw_r2r(regs,regd) mmx_r2r (pmulhuw, regs, regd) + +#define prefetcht0(mem) mmx_fetch (mem, t0) +#define prefetcht1(mem) mmx_fetch (mem, t1) +#define prefetcht2(mem) mmx_fetch (mem, t2) +#define prefetchnta(mem) mmx_fetch (mem, nta) + +#define psadbw_m2r(var,reg) mmx_m2r (psadbw, var, reg) +#define psadbw_r2r(regs,regd) mmx_r2r (psadbw, regs, regd) + +#define pshufw_m2r(var,reg,imm) mmx_m2ri(pshufw, var, reg, imm) +#define pshufw_r2r(regs,regd,imm) mmx_r2ri(pshufw, regs, regd, imm) + +#define sfence() __asm__ __volatile__ ("sfence\n\t") diff --git a/src/libmpeg2new/include/mpeg2.h b/src/libmpeg2new/include/mpeg2.h new file mode 100644 index 000000000..ebc3056af --- /dev/null +++ b/src/libmpeg2new/include/mpeg2.h @@ -0,0 +1,166 @@ +/* + * mpeg2.h + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> + * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * See http://libmpeg2.sourceforge.net/ for updates. + * + * mpeg2dec 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. + * + * mpeg2dec 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef MPEG2_H +#define MPEG2_H + +#define MPEG2_VERSION(a,b,c) (((a)<<16)|((b)<<8)|(c)) +#define MPEG2_RELEASE MPEG2_VERSION (0, 3, 2) /* 0.3.2 */ + +#define SEQ_FLAG_MPEG2 1 +#define SEQ_FLAG_CONSTRAINED_PARAMETERS 2 +#define SEQ_FLAG_PROGRESSIVE_SEQUENCE 4 +#define SEQ_FLAG_LOW_DELAY 8 +#define SEQ_FLAG_COLOUR_DESCRIPTION 16 + +#define SEQ_MASK_VIDEO_FORMAT 0xe0 +#define SEQ_VIDEO_FORMAT_COMPONENT 0 +#define SEQ_VIDEO_FORMAT_PAL 0x20 +#define SEQ_VIDEO_FORMAT_NTSC 0x40 +#define SEQ_VIDEO_FORMAT_SECAM 0x60 +#define SEQ_VIDEO_FORMAT_MAC 0x80 +#define SEQ_VIDEO_FORMAT_UNSPECIFIED 0xa0 + +typedef struct { + unsigned int width, height; + unsigned int chroma_width, chroma_height; + unsigned int byte_rate; + unsigned int vbv_buffer_size; + uint32_t flags; + + unsigned int picture_width, picture_height; + unsigned int display_width, display_height; + unsigned int pixel_width, pixel_height; + unsigned int frame_period; + + uint8_t profile_level_id; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coefficients; +} mpeg2_sequence_t; + +#define GOP_FLAG_DROP_FRAME 1 +#define GOP_FLAG_BROKEN_LINK 2 +#define GOP_FLAG_CLOSED_GOP 4 + +typedef struct { + uint8_t hours; + uint8_t minutes; + uint8_t seconds; + uint8_t pictures; + uint32_t flags; +} mpeg2_gop_t; + +#define PIC_MASK_CODING_TYPE 7 +#define PIC_FLAG_CODING_TYPE_I 1 +#define PIC_FLAG_CODING_TYPE_P 2 +#define PIC_FLAG_CODING_TYPE_B 3 +#define PIC_FLAG_CODING_TYPE_D 4 + +#define PIC_FLAG_TOP_FIELD_FIRST 8 +#define PIC_FLAG_PROGRESSIVE_FRAME 16 +#define PIC_FLAG_COMPOSITE_DISPLAY 32 +#define PIC_FLAG_SKIP 64 +#define PIC_FLAG_PTS 128 +#define PIC_MASK_COMPOSITE_DISPLAY 0xfffff000 + +typedef struct { + unsigned int temporal_reference; + unsigned int nb_fields; + uint32_t pts; + uint32_t flags; + struct { + int x, y; + } display_offset[3]; +} mpeg2_picture_t; + +typedef struct { + uint8_t * buf[3]; + void * id; +} mpeg2_fbuf_t; + +typedef struct { + const mpeg2_sequence_t * sequence; + const mpeg2_gop_t * gop; + const mpeg2_picture_t * current_picture; + const mpeg2_picture_t * current_picture_2nd; + const mpeg2_fbuf_t * current_fbuf; + const mpeg2_picture_t * display_picture; + const mpeg2_picture_t * display_picture_2nd; + const mpeg2_fbuf_t * display_fbuf; + const mpeg2_fbuf_t * discard_fbuf; + const uint8_t * user_data; + int user_data_len; +} mpeg2_info_t; + +typedef struct mpeg2dec_s mpeg2dec_t; +typedef struct mpeg2_decoder_s mpeg2_decoder_t; + +typedef enum { + STATE_BUFFER = 0, + STATE_SEQUENCE = 1, + STATE_SEQUENCE_REPEATED = 2, + STATE_GOP = 3, + STATE_PICTURE = 4, + STATE_SLICE_1ST = 5, + STATE_PICTURE_2ND = 6, + STATE_SLICE = 7, + STATE_END = 8, + STATE_INVALID = 9 +} mpeg2_state_t; + +struct convert_init_s; +void mpeg2_convert (mpeg2dec_t * mpeg2dec, + void (* convert) (int, int, uint32_t, void *, + struct convert_init_s *), void * arg); +void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id); +void mpeg2_custom_fbuf (mpeg2dec_t * mpeg2dec, int custom_fbuf); + +#define MPEG2_ACCEL_X86_MMX 1 +#define MPEG2_ACCEL_X86_3DNOW 2 +#define MPEG2_ACCEL_X86_MMXEXT 4 +#define MPEG2_ACCEL_PPC_ALTIVEC 1 +#define MPEG2_ACCEL_ALPHA 1 +#define MPEG2_ACCEL_ALPHA_MVI 2 +#define MPEG2_ACCEL_MLIB 0x40000000 +#define MPEG2_ACCEL_DETECT 0x80000000 + +uint32_t mpeg2_accel (uint32_t accel); +mpeg2dec_t * mpeg2_init (void); +const mpeg2_info_t * mpeg2_info (mpeg2dec_t * mpeg2dec); +void mpeg2_close (mpeg2dec_t * mpeg2dec); + +void mpeg2_buffer (mpeg2dec_t * mpeg2dec, uint8_t * start, uint8_t * end); +int mpeg2_getpos (mpeg2dec_t * mpeg2dec); +mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec); + +void mpeg2_skip (mpeg2dec_t * mpeg2dec, int skip); +void mpeg2_slice_region (mpeg2dec_t * mpeg2dec, int start, int end); + +void mpeg2_pts (mpeg2dec_t * mpeg2dec, uint32_t pts); + +void mpeg2_init_fbuf (mpeg2_decoder_t * decoder, uint8_t * current_fbuf[3], + uint8_t * forward_fbuf[3], uint8_t * backward_fbuf[3]); +void mpeg2_slice (mpeg2_decoder_t * decoder, int code, const uint8_t * buffer); + +#endif /* MPEG2_H */ diff --git a/src/libmpeg2new/include/sse.h b/src/libmpeg2new/include/sse.h new file mode 100644 index 000000000..4bd853f8b --- /dev/null +++ b/src/libmpeg2new/include/sse.h @@ -0,0 +1,256 @@ +/* + * sse.h + * Copyright (C) 1999-2003 R. Fisher + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * See http://libmpeg2.sourceforge.net/ for updates. + * + * mpeg2dec 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. + * + * mpeg2dec 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +typedef union { + float sf[4]; /* Single-precision (32-bit) value */ +} ATTR_ALIGN(16) sse_t; /* On a 16 byte (128-bit) boundary */ + + +#define sse_i2r(op, imm, reg) \ + __asm__ __volatile__ (#op " %0, %%" #reg \ + : /* nothing */ \ + : "X" (imm) ) + +#define sse_m2r(op, mem, reg) \ + __asm__ __volatile__ (#op " %0, %%" #reg \ + : /* nothing */ \ + : "X" (mem)) + +#define sse_r2m(op, reg, mem) \ + __asm__ __volatile__ (#op " %%" #reg ", %0" \ + : "=X" (mem) \ + : /* nothing */ ) + +#define sse_r2r(op, regs, regd) \ + __asm__ __volatile__ (#op " %" #regs ", %" #regd) + +#define sse_r2ri(op, regs, regd, imm) \ + __asm__ __volatile__ (#op " %0, %%" #regs ", %%" #regd \ + : /* nothing */ \ + : "X" (imm) ) + +#define sse_m2ri(op, mem, reg, subop) \ + __asm__ __volatile__ (#op " %0, %%" #reg ", " #subop \ + : /* nothing */ \ + : "X" (mem)) + + +#define movaps_m2r(var, reg) sse_m2r(movaps, var, reg) +#define movaps_r2m(reg, var) sse_r2m(movaps, reg, var) +#define movaps_r2r(regs, regd) sse_r2r(movaps, regs, regd) + +#define movntps_r2m(xmmreg, var) sse_r2m(movntps, xmmreg, var) + +#define movups_m2r(var, reg) sse_m2r(movups, var, reg) +#define movups_r2m(reg, var) sse_r2m(movups, reg, var) +#define movups_r2r(regs, regd) sse_r2r(movups, regs, regd) + +#define movhlps_r2r(regs, regd) sse_r2r(movhlps, regs, regd) + +#define movlhps_r2r(regs, regd) sse_r2r(movlhps, regs, regd) + +#define movhps_m2r(var, reg) sse_m2r(movhps, var, reg) +#define movhps_r2m(reg, var) sse_r2m(movhps, reg, var) + +#define movlps_m2r(var, reg) sse_m2r(movlps, var, reg) +#define movlps_r2m(reg, var) sse_r2m(movlps, reg, var) + +#define movss_m2r(var, reg) sse_m2r(movss, var, reg) +#define movss_r2m(reg, var) sse_r2m(movss, reg, var) +#define movss_r2r(regs, regd) sse_r2r(movss, regs, regd) + +#define shufps_m2r(var, reg, index) sse_m2ri(shufps, var, reg, index) +#define shufps_r2r(regs, regd, index) sse_r2ri(shufps, regs, regd, index) + +#define cvtpi2ps_m2r(var, xmmreg) sse_m2r(cvtpi2ps, var, xmmreg) +#define cvtpi2ps_r2r(mmreg, xmmreg) sse_r2r(cvtpi2ps, mmreg, xmmreg) + +#define cvtps2pi_m2r(var, mmreg) sse_m2r(cvtps2pi, var, mmreg) +#define cvtps2pi_r2r(xmmreg, mmreg) sse_r2r(cvtps2pi, mmreg, xmmreg) + +#define cvttps2pi_m2r(var, mmreg) sse_m2r(cvttps2pi, var, mmreg) +#define cvttps2pi_r2r(xmmreg, mmreg) sse_r2r(cvttps2pi, mmreg, xmmreg) + +#define cvtsi2ss_m2r(var, xmmreg) sse_m2r(cvtsi2ss, var, xmmreg) +#define cvtsi2ss_r2r(reg, xmmreg) sse_r2r(cvtsi2ss, reg, xmmreg) + +#define cvtss2si_m2r(var, reg) sse_m2r(cvtss2si, var, reg) +#define cvtss2si_r2r(xmmreg, reg) sse_r2r(cvtss2si, xmmreg, reg) + +#define cvttss2si_m2r(var, reg) sse_m2r(cvtss2si, var, reg) +#define cvttss2si_r2r(xmmreg, reg) sse_r2r(cvtss2si, xmmreg, reg) + +#define movmskps(xmmreg, reg) \ + __asm__ __volatile__ ("movmskps %" #xmmreg ", %" #reg) + +#define addps_m2r(var, reg) sse_m2r(addps, var, reg) +#define addps_r2r(regs, regd) sse_r2r(addps, regs, regd) + +#define addss_m2r(var, reg) sse_m2r(addss, var, reg) +#define addss_r2r(regs, regd) sse_r2r(addss, regs, regd) + +#define subps_m2r(var, reg) sse_m2r(subps, var, reg) +#define subps_r2r(regs, regd) sse_r2r(subps, regs, regd) + +#define subss_m2r(var, reg) sse_m2r(subss, var, reg) +#define subss_r2r(regs, regd) sse_r2r(subss, regs, regd) + +#define mulps_m2r(var, reg) sse_m2r(mulps, var, reg) +#define mulps_r2r(regs, regd) sse_r2r(mulps, regs, regd) + +#define mulss_m2r(var, reg) sse_m2r(mulss, var, reg) +#define mulss_r2r(regs, regd) sse_r2r(mulss, regs, regd) + +#define divps_m2r(var, reg) sse_m2r(divps, var, reg) +#define divps_r2r(regs, regd) sse_r2r(divps, regs, regd) + +#define divss_m2r(var, reg) sse_m2r(divss, var, reg) +#define divss_r2r(regs, regd) sse_r2r(divss, regs, regd) + +#define rcpps_m2r(var, reg) sse_m2r(rcpps, var, reg) +#define rcpps_r2r(regs, regd) sse_r2r(rcpps, regs, regd) + +#define rcpss_m2r(var, reg) sse_m2r(rcpss, var, reg) +#define rcpss_r2r(regs, regd) sse_r2r(rcpss, regs, regd) + +#define rsqrtps_m2r(var, reg) sse_m2r(rsqrtps, var, reg) +#define rsqrtps_r2r(regs, regd) sse_r2r(rsqrtps, regs, regd) + +#define rsqrtss_m2r(var, reg) sse_m2r(rsqrtss, var, reg) +#define rsqrtss_r2r(regs, regd) sse_r2r(rsqrtss, regs, regd) + +#define sqrtps_m2r(var, reg) sse_m2r(sqrtps, var, reg) +#define sqrtps_r2r(regs, regd) sse_r2r(sqrtps, regs, regd) + +#define sqrtss_m2r(var, reg) sse_m2r(sqrtss, var, reg) +#define sqrtss_r2r(regs, regd) sse_r2r(sqrtss, regs, regd) + +#define andps_m2r(var, reg) sse_m2r(andps, var, reg) +#define andps_r2r(regs, regd) sse_r2r(andps, regs, regd) + +#define andnps_m2r(var, reg) sse_m2r(andnps, var, reg) +#define andnps_r2r(regs, regd) sse_r2r(andnps, regs, regd) + +#define orps_m2r(var, reg) sse_m2r(orps, var, reg) +#define orps_r2r(regs, regd) sse_r2r(orps, regs, regd) + +#define xorps_m2r(var, reg) sse_m2r(xorps, var, reg) +#define xorps_r2r(regs, regd) sse_r2r(xorps, regs, regd) + +#define maxps_m2r(var, reg) sse_m2r(maxps, var, reg) +#define maxps_r2r(regs, regd) sse_r2r(maxps, regs, regd) + +#define maxss_m2r(var, reg) sse_m2r(maxss, var, reg) +#define maxss_r2r(regs, regd) sse_r2r(maxss, regs, regd) + +#define minps_m2r(var, reg) sse_m2r(minps, var, reg) +#define minps_r2r(regs, regd) sse_r2r(minps, regs, regd) + +#define minss_m2r(var, reg) sse_m2r(minss, var, reg) +#define minss_r2r(regs, regd) sse_r2r(minss, regs, regd) + +#define cmpps_m2r(var, reg, op) sse_m2ri(cmpps, var, reg, op) +#define cmpps_r2r(regs, regd, op) sse_r2ri(cmpps, regs, regd, op) + +#define cmpeqps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 0) +#define cmpeqps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 0) + +#define cmpltps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 1) +#define cmpltps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 1) + +#define cmpleps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 2) +#define cmpleps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 2) + +#define cmpunordps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 3) +#define cmpunordps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 3) + +#define cmpneqps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 4) +#define cmpneqps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 4) + +#define cmpnltps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 5) +#define cmpnltps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 5) + +#define cmpnleps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 6) +#define cmpnleps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 6) + +#define cmpordps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 7) +#define cmpordps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 7) + +#define cmpss_m2r(var, reg, op) sse_m2ri(cmpss, var, reg, op) +#define cmpss_r2r(regs, regd, op) sse_r2ri(cmpss, regs, regd, op) + +#define cmpeqss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 0) +#define cmpeqss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 0) + +#define cmpltss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 1) +#define cmpltss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 1) + +#define cmpless_m2r(var, reg) sse_m2ri(cmpss, var, reg, 2) +#define cmpless_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 2) + +#define cmpunordss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 3) +#define cmpunordss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 3) + +#define cmpneqss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 4) +#define cmpneqss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 4) + +#define cmpnltss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 5) +#define cmpnltss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 5) + +#define cmpnless_m2r(var, reg) sse_m2ri(cmpss, var, reg, 6) +#define cmpnless_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 6) + +#define cmpordss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 7) +#define cmpordss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 7) + +#define comiss_m2r(var, reg) sse_m2r(comiss, var, reg) +#define comiss_r2r(regs, regd) sse_r2r(comiss, regs, regd) + +#define ucomiss_m2r(var, reg) sse_m2r(ucomiss, var, reg) +#define ucomiss_r2r(regs, regd) sse_r2r(ucomiss, regs, regd) + +#define unpcklps_m2r(var, reg) sse_m2r(unpcklps, var, reg) +#define unpcklps_r2r(regs, regd) sse_r2r(unpcklps, regs, regd) + +#define unpckhps_m2r(var, reg) sse_m2r(unpckhps, var, reg) +#define unpckhps_r2r(regs, regd) sse_r2r(unpckhps, regs, regd) + +#define fxrstor(mem) \ + __asm__ __volatile__ ("fxrstor %0" \ + : /* nothing */ \ + : "X" (mem)) + +#define fxsave(mem) \ + __asm__ __volatile__ ("fxsave %0" \ + : /* nothing */ \ + : "X" (mem)) + +#define stmxcsr(mem) \ + __asm__ __volatile__ ("stmxcsr %0" \ + : /* nothing */ \ + : "X" (mem)) + +#define ldmxcsr(mem) \ + __asm__ __volatile__ ("ldmxcsr %0" \ + : /* nothing */ \ + : "X" (mem)) + diff --git a/src/libmpeg2new/include/stamp-h1 b/src/libmpeg2new/include/stamp-h1 new file mode 100644 index 000000000..b330768e9 --- /dev/null +++ b/src/libmpeg2new/include/stamp-h1 @@ -0,0 +1 @@ +timestamp for include/config.h diff --git a/src/libmpeg2new/include/tendra.h b/src/libmpeg2new/include/tendra.h new file mode 100644 index 000000000..09900916a --- /dev/null +++ b/src/libmpeg2new/include/tendra.h @@ -0,0 +1,35 @@ +/* + * tendra.h + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> + * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * See http://libmpeg2.sourceforge.net/ for updates. + * + * mpeg2dec 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. + * + * mpeg2dec 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#pragma TenDRA begin +#pragma TenDRA longlong type warning + +#ifdef TenDRA_check + +#pragma TenDRA conversion analysis (pointer-int explicit) off +#pragma TenDRA implicit function declaration off + +/* avoid the "No declarations in translation unit" problem */ +int TenDRA; + +#endif /* TenDRA_check */ diff --git a/src/libmpeg2new/include/video_out.h b/src/libmpeg2new/include/video_out.h new file mode 100644 index 000000000..e7f661bbb --- /dev/null +++ b/src/libmpeg2new/include/video_out.h @@ -0,0 +1,53 @@ +/* + * video_out.h + * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> + * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> + * + * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. + * See http://libmpeg2.sourceforge.net/ for updates. + * + * mpeg2dec 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. + * + * mpeg2dec 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +struct convert_init_s; +typedef struct { + void (* convert) (int, int, uint32_t, void *, struct convert_init_s *); +} vo_setup_result_t; + +typedef struct vo_instance_s vo_instance_t; +struct vo_instance_s { + int (* setup) (vo_instance_t * instance, int width, int height, + vo_setup_result_t * result); + void (* setup_fbuf) (vo_instance_t * instance, uint8_t ** buf, void ** id); + void (* set_fbuf) (vo_instance_t * instance, uint8_t ** buf, void ** id); + void (* start_fbuf) (vo_instance_t * instance, + uint8_t * const * buf, void * id); + void (* draw) (vo_instance_t * instance, uint8_t * const * buf, void * id); + void (* discard) (vo_instance_t * instance, + uint8_t * const * buf, void * id); + void (* close) (vo_instance_t * instance); +}; + +typedef vo_instance_t * vo_open_t (void); + +typedef struct { + char * name; + vo_open_t * open; +} vo_driver_t; + +void vo_accel (uint32_t accel); + +/* return NULL terminated array of all drivers */ +vo_driver_t * vo_drivers (void); diff --git a/src/libmpeg2new/libmpeg2/Makefile.am b/src/libmpeg2new/libmpeg2/Makefile.am index ed9b50e21..3ba2d6542 100644 --- a/src/libmpeg2new/libmpeg2/Makefile.am +++ b/src/libmpeg2new/libmpeg2/Makefile.am @@ -1,19 +1,16 @@ -AM_CFLAGS = $(OPT_CFLAGS) $(LIBMPEG2_CFLAGS) +include $(top_srcdir)/misc/Makefile.common + + +AM_CFLAGS = @ANSI_FLAGS@ + +noinst_LTLIBRARIES = libmpeg2.la libmpeg2arch.la -lib_LTLIBRARIES = libmpeg2.la libmpeg2_la_SOURCES = alloc.c header.c decode.c slice.c motion_comp.c idct.c \ - motion_comp_mlib.c idct_mlib.c -libmpeg2_la_LIBADD = libmpeg2arch.la $(LIBMPEG2_LIBS) -libmpeg2_la_LDFLAGS = -no-undefined + motion_comp_mlib.c idct_mlib.c +libmpeg2_la_LIBADD = libmpeg2arch.la -noinst_LTLIBRARIES = libmpeg2arch.la libmpeg2arch_la_SOURCES = motion_comp_mmx.c idct_mmx.c \ - motion_comp_altivec.c idct_altivec.c \ - motion_comp_alpha.c idct_alpha.c \ - cpu_accel.c cpu_state.c -libmpeg2arch_la_CFLAGS = $(OPT_CFLAGS) $(ARCH_OPT_CFLAGS) $(LIBMPEG2_CFLAGS) - -pkgconfigdir = $(libdir)/pkgconfig -pkgconfig_DATA = libmpeg2.pc + motion_comp_altivec.c idct_altivec.c \ + motion_comp_alpha.c idct_alpha.c \ + cpu_accel.c cpu_state.c -EXTRA_DIST = configure.incl vlc.h mpeg2_internal.h diff --git a/src/libmpeg2new/libmpeg2/alloc.c b/src/libmpeg2new/libmpeg2/alloc.c index 2e4792e94..67a5d5c6a 100644 --- a/src/libmpeg2new/libmpeg2/alloc.c +++ b/src/libmpeg2new/libmpeg2/alloc.c @@ -26,7 +26,7 @@ #include <stdlib.h> #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" #if defined(HAVE_MEMALIGN) && !defined(__cplusplus) diff --git a/src/libmpeg2new/libmpeg2/cpu_accel.c b/src/libmpeg2new/libmpeg2/cpu_accel.c index 97e5ea3ca..a1096f2ef 100644 --- a/src/libmpeg2new/libmpeg2/cpu_accel.c +++ b/src/libmpeg2new/libmpeg2/cpu_accel.c @@ -25,7 +25,7 @@ #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #ifdef ACCEL_DETECT #ifdef ARCH_X86 diff --git a/src/libmpeg2new/libmpeg2/cpu_state.c b/src/libmpeg2new/libmpeg2/cpu_state.c index a94e5fedc..6761747fa 100644 --- a/src/libmpeg2new/libmpeg2/cpu_state.c +++ b/src/libmpeg2new/libmpeg2/cpu_state.c @@ -26,11 +26,11 @@ #include <stdlib.h> #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "attributes.h" +#include "../include/attributes.h" #ifdef ARCH_X86 -#include "mmx.h" +#include "../include/mmx.h" #endif void (* mpeg2_cpu_state_save) (cpu_state_t * state) = NULL; diff --git a/src/libmpeg2new/libmpeg2/decode.c b/src/libmpeg2new/libmpeg2/decode.c index df2ca2f28..382798f75 100644 --- a/src/libmpeg2new/libmpeg2/decode.c +++ b/src/libmpeg2new/libmpeg2/decode.c @@ -23,13 +23,14 @@ #include "config.h" +#include <stdio.h> /* For testing printf */ #include <string.h> /* memcmp/memset, try to remove */ #include <stdlib.h> #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "convert.h" +#include "../include/convert.h" static int mpeg2_accels = 0; @@ -160,6 +161,20 @@ mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec) { int size_buffer, size_chunk, copied; + printf("mpeg2dec-lib:decode.c:CODE=%x\n",mpeg2dec->code); + printf("mpeg2_parse:mpeg2dec->fbuf[0]=%p",mpeg2dec->fbuf[0]); + if (mpeg2dec->fbuf[0]) printf(", img=%p\n", mpeg2dec->fbuf[0]->id); + else printf("\n"); + printf("mpeg2_parse:mpeg2dec->fbuf[1]=%p",mpeg2dec->fbuf[1]); + if (mpeg2dec->fbuf[1]) printf(", img=%p\n", mpeg2dec->fbuf[1]->id); + else printf("\n"); + printf("mpeg2_parse:mpeg2dec->fbuf[2]=%p",mpeg2dec->fbuf[2]); + if (mpeg2dec->fbuf[2]) printf(", img=%p\n", mpeg2dec->fbuf[2]->id); + else printf("\n"); + printf("mpeg2_parse:mpeg2dec->decoder->pictures[0]=%p\n",&mpeg2dec->pictures[0]); + printf("mpeg2_parse:mpeg2dec->decoder->pictures[1]=%p\n",&mpeg2dec->pictures[1]); + printf("mpeg2_parse:mpeg2dec->decoder->pictures[2]=%p\n",&mpeg2dec->pictures[2]); + printf("mpeg2_parse:mpeg2dec->decoder->pictures[3]=%p\n",&mpeg2dec->pictures[3]); if (mpeg2dec->action) { mpeg2_state_t state; @@ -187,6 +202,7 @@ mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec) /* filled the chunk buffer without finding a start code */ mpeg2dec->bytes_since_pts += size_chunk; mpeg2dec->action = seek_chunk; + printf("mpeg2dec:action = mpeg2_seek_chunk\n"); return STATE_INVALID; } } @@ -202,22 +218,80 @@ mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec) if (seek_chunk (mpeg2dec) == STATE_BUFFER) return STATE_BUFFER; } - + printf("mpeg2dec-lib:decode.c:CODE2=%x\n",mpeg2dec->code); + printf("mpeg2_parse:mpeg2dec->fbuf[0]=%p\n",mpeg2dec->fbuf[0]); + printf("mpeg2_parse:mpeg2dec->fbuf[1]=%p\n",mpeg2dec->fbuf[1]); + printf("mpeg2_parse:mpeg2dec->fbuf[2]=%p\n",mpeg2dec->fbuf[2]); switch (mpeg2dec->code) { case 0x00: mpeg2dec->action = mpeg2_header_picture_start; + printf("mpeg2dec:action = mpeg2_header_picture_start\n"); + printf("mpeg2dec:returning state = %d\n", mpeg2dec->state); + if (mpeg2dec->state == STATE_SLICE) { + printf("mpeg2dec:slicing info0\n"); + mpeg2dec->info.current_picture = mpeg2dec->info.current_picture_2nd = NULL; + mpeg2dec->info.display_picture = mpeg2dec->info.display_picture_2nd = NULL; + mpeg2dec->info.current_fbuf = mpeg2dec->info.display_fbuf = mpeg2dec->info.discard_fbuf = NULL; + printf("mpeg2dec:reset_info in CODE\n"); + mpeg2dec->info.user_data = NULL; + mpeg2dec->info.user_data_len = 0; + + mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0]; + if (mpeg2dec->decoder.coding_type == B_TYPE) { + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->fbuf[0]=0; + printf("mpeg2dec:mpeg_parse:discard_fbuf=fbuf[0]\n"); + } else { + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[2]; + mpeg2dec->fbuf[2]=0; + printf("mpeg2dec:mpeg_parse:discard_fbuf=fbuf[2]\n"); + } + } + return mpeg2dec->state; case 0xb7: mpeg2dec->action = mpeg2_header_end; + printf("mpeg2dec:action = mpeg2_header_end\n"); break; case 0xb3: case 0xb8: mpeg2dec->action = mpeg2_parse_header; + printf("mpeg2dec:action = mpeg2_parse_header\n"); break; default: mpeg2dec->action = seek_chunk; + printf("mpeg2dec:action = seek_chunk\n"); + printf("mpeg2dec:returning state = %d\n", mpeg2dec->state); return STATE_INVALID; } + if (mpeg2dec->state == STATE_SLICE) { + printf("mpeg2dec:slicing info\n"); + mpeg2dec->info.current_picture = mpeg2dec->info.current_picture_2nd = NULL; + mpeg2dec->info.display_picture = mpeg2dec->info.display_picture_2nd = NULL; + mpeg2dec->info.current_fbuf = mpeg2dec->info.display_fbuf = mpeg2dec->info.discard_fbuf = NULL; + printf("mpeg2dec:reset_info in CODE\n"); + mpeg2dec->info.user_data = NULL; + mpeg2dec->info.user_data_len = 0; + + mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0]; + if (mpeg2dec->decoder.coding_type == B_TYPE) { + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->fbuf[0]=0; + printf("mpeg2dec:mpeg_parse:discard_fbuf=fbuf[0]\n"); + } else { + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[2]; + mpeg2dec->fbuf[2]=0; + printf("mpeg2dec:mpeg_parse:discard_fbuf=fbuf[2]\n"); + } + } + + + + printf("mpeg2dec:returning state = %d\n", mpeg2dec->state); return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID; } @@ -230,6 +304,7 @@ mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) int size_buffer, size_chunk, copied; mpeg2dec->action = mpeg2_parse_header; + printf("mpeg2dec:action = mpeg2_parse_header\n"); while (1) { size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE - @@ -248,6 +323,7 @@ mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) mpeg2dec->bytes_since_pts += size_chunk; mpeg2dec->code = 0xb4; mpeg2dec->action = seek_header; + printf("mpeg2dec:action = seek_header\n"); return STATE_INVALID; } } @@ -256,15 +332,18 @@ mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) { mpeg2dec->code = mpeg2dec->buf_start[-1]; mpeg2dec->action = seek_header; + printf("mpeg2dec:action = seek_header\n"); return STATE_INVALID; } mpeg2dec->code = mpeg2dec->buf_start[-1]; + printf("mpeg2dec:CODE3=%x, state=%x\n",mpeg2dec->code, mpeg2dec->state); switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) { /* state transition after a sequence header */ case RECEIVED (0x00, STATE_SEQUENCE): mpeg2dec->action = mpeg2_header_picture_start; + printf("mpeg2dec:action = mpeg2_header_picture_start\n"); case RECEIVED (0xb8, STATE_SEQUENCE): mpeg2_header_sequence_finalize (mpeg2dec); break; @@ -272,11 +351,13 @@ mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) /* other legal state transitions */ case RECEIVED (0x00, STATE_GOP): mpeg2dec->action = mpeg2_header_picture_start; + printf("mpeg2dec:action = mpeg2_header_picture_start\n"); break; case RECEIVED (0x01, STATE_PICTURE): case RECEIVED (0x01, STATE_PICTURE_2ND): mpeg2_header_matrix_finalize (mpeg2dec); mpeg2dec->action = mpeg2_header_slice_start; + printf("mpeg2dec:action = mpeg2_header_slice_start\n"); break; /* legal headers within a given state */ @@ -292,6 +373,7 @@ mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) default: mpeg2dec->action = seek_header; + printf("mpeg2dec:action = seek_header\n"); return STATE_INVALID; } @@ -359,6 +441,10 @@ void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id) void mpeg2_custom_fbuf (mpeg2dec_t * mpeg2dec, int custom_fbuf) { mpeg2dec->custom_fbuf = custom_fbuf; + mpeg2dec->fbuf[0] = NULL; + mpeg2dec->fbuf[1] = NULL; + mpeg2dec->fbuf[2] = NULL; + } void mpeg2_skip (mpeg2dec_t * mpeg2dec, int skip) @@ -414,14 +500,20 @@ mpeg2dec_t * mpeg2_init (void) mpeg2dec->shift = 0xffffff00; mpeg2dec->action = mpeg2_seek_sequence; + printf("mpeg2dec:action = mpeg2_seek_sequence\n"); mpeg2dec->code = 0xb4; mpeg2dec->first_decode_slice = 1; mpeg2dec->nb_decode_slices = 0xb0 - 1; mpeg2dec->convert_id = NULL; /* initialize substructures */ + printf("mpeg2_init:mpeg2dec->fbuf[0]=%p\n",mpeg2dec->fbuf[0]); + printf("mpeg2_init:mpeg2dec->fbuf[1]=%p\n",mpeg2dec->fbuf[1]); + printf("mpeg2_init:mpeg2dec->fbuf[2]=%p\n",mpeg2dec->fbuf[2]); mpeg2_header_state_init (mpeg2dec); - + printf("mpeg2_init:mpeg2dec->fbuf[0]=%p\n",mpeg2dec->fbuf[0]); + printf("mpeg2_init:mpeg2dec->fbuf[1]=%p\n",mpeg2dec->fbuf[1]); + printf("mpeg2_init:mpeg2dec->fbuf[2]=%p\n",mpeg2dec->fbuf[2]); return mpeg2dec; } diff --git a/src/libmpeg2new/libmpeg2/header.c b/src/libmpeg2new/libmpeg2/header.c index 55f16f1ee..62c87c700 100644 --- a/src/libmpeg2new/libmpeg2/header.c +++ b/src/libmpeg2new/libmpeg2/header.c @@ -23,14 +23,16 @@ #include "config.h" +#include <stdio.h> /* For printf */ #include <inttypes.h> #include <stdlib.h> /* defines NULL */ #include <string.h> /* memcmp */ +#include <assert.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "convert.h" -#include "attributes.h" +#include "../include/convert.h" +#include "../include/attributes.h" #define SEQ_EXT 2 #define SEQ_DISPLAY_EXT 4 @@ -91,6 +93,7 @@ static void reset_info (mpeg2_info_t * info) info->current_picture = info->current_picture_2nd = NULL; info->display_picture = info->display_picture_2nd = NULL; info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL; + printf("mpeg2dec:reset_info\n"); info->user_data = NULL; info->user_data_len = 0; } @@ -362,13 +365,19 @@ void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int coding_type) if (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf && mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) { mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf; - mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0]; - if ((coding_type == B_TYPE) || - (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { - if ((coding_type == B_TYPE) || (mpeg2dec->convert_start)) - mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; - mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; - } + if (!mpeg2dec->custom_fbuf) { + printf("mpeg2dec:set_fbuf:NO NO NO!!!\n"); + mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0]; + if ((coding_type == B_TYPE) || + (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; + if ((coding_type == B_TYPE) || (mpeg2dec->convert_start)) { + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->fbuf[0]=0; + printf("mpeg2dec:set_fbuf:discard_fbuf=fbuf[0]\n"); + } + } + } break; } } @@ -446,9 +455,17 @@ int mpeg2_header_picture (mpeg2dec_t * mpeg2dec) mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; } } - if (!low_delay + !mpeg2dec->convert_start) + if (!low_delay + !mpeg2dec->convert_start) { mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert_start]; + // FIXME: Might want to wipe this whole section, once pictures is sorted. + // mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert_start]=0; + printf("mpeg2dec:header_picture:discard_fbuf=??\n"); + printf("mpeg2dec:header_picture:express = %d\n",!low_delay + !mpeg2dec->convert_start); + printf("mpeg2dec:header_picture:fbuf[0]=%p\n", mpeg2dec->fbuf[0]); + printf("mpeg2dec:header_picture:fbuf[1]=%p\n", mpeg2dec->fbuf[1]); + printf("mpeg2dec:header_picture:fbuf[2]=%p\n", mpeg2dec->fbuf[2]); + } } if (!mpeg2dec->custom_fbuf) { while (mpeg2dec->alloc_index < 3) { @@ -471,6 +488,7 @@ int mpeg2_header_picture (mpeg2dec_t * mpeg2dec) fbuf->buf[2] = fbuf->buf[1] + (size >> 2); } } + assert(0); mpeg2_set_fbuf (mpeg2dec, type); } } else { @@ -695,9 +713,51 @@ mpeg2_state_t mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec) mpeg2dec->fbuf[b_type]->buf); } mpeg2dec->action = NULL; + printf("mpeg2dec:action = NULL\n"); return (mpeg2_state_t)-1; } +mpeg2_state_t mpeg2_header_end_btype2 (mpeg2dec_t * mpeg2dec) +{ + mpeg2dec->info.display_fbuf = 0; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[1]; + printf("mpeg2dec:header_end_btype2:discard_fbuf=1\n"); + mpeg2dec->fbuf[1]=0; + mpeg2dec->action = mpeg2_seek_sequence; + printf("mpeg2dec:action = mpeg2_seek_sequence\n"); + mpeg2dec->first = 1; + return STATE_END; +} +mpeg2_state_t mpeg2_header_end_btype (mpeg2dec_t * mpeg2dec) +{ + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[2]; + printf("mpeg2dec:header_end_btype:discard_fbuf=0\n"); + mpeg2dec->fbuf[2]=0; + mpeg2dec->action = mpeg2_header_end_btype2; + printf("mpeg2dec:action = mpeg2_header_end_btype2\n"); + return STATE_SLICE; +} +mpeg2_state_t mpeg2_header_end_itype2 (mpeg2dec_t * mpeg2dec) +{ + mpeg2dec->info.display_fbuf = 0; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->fbuf[0]=0; + mpeg2dec->action = mpeg2_seek_sequence; + printf("mpeg2dec:action = mpeg2_seek_sequence\n"); + mpeg2dec->first = 1; + return STATE_END; +} +mpeg2_state_t mpeg2_header_end_itype (mpeg2dec_t * mpeg2dec) +{ + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[1]; + mpeg2dec->fbuf[1]=0; + mpeg2dec->action = mpeg2_header_end_itype2; + printf("mpeg2dec:action = mpeg2_header_end_itype2\n"); + return STATE_SLICE; +} + mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec) { mpeg2_picture_t * picture; @@ -710,16 +770,58 @@ mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec) mpeg2dec->state = STATE_END; reset_info (&(mpeg2dec->info)); + if (b_type) { + mpeg2dec->info.display_picture = picture; + if (picture->nb_fields == 1) + mpeg2dec->info.display_picture_2nd = picture + 1; + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->fbuf[0]=0; + mpeg2dec->action = mpeg2_header_end_btype; + printf("mpeg2dec:action = mpeg2_header_end_btype\n"); + return STATE_SLICE; + } else { + mpeg2dec->info.display_picture = picture; + if (picture->nb_fields == 1) + mpeg2dec->info.display_picture_2nd = picture + 1; + if (mpeg2dec->fbuf[2]) { + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[2]; + mpeg2dec->fbuf[2]=0; + mpeg2dec->action = mpeg2_header_end_itype; + printf("mpeg2dec:action = mpeg2_header_end_itype\n"); + return STATE_SLICE; + } else { + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; + mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[1]; + mpeg2dec->fbuf[1]=0; + mpeg2dec->action = mpeg2_header_end_itype2; + printf("mpeg2dec:action = mpeg2_header_end_itype2\n"); + return STATE_SLICE; + } + + } + + +#if 0 if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { mpeg2dec->info.display_picture = picture; if (picture->nb_fields == 1) mpeg2dec->info.display_picture_2nd = picture + 1; mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type]; - if (!mpeg2dec->convert_start) + if (!mpeg2dec->convert_start) { mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1]; - } else if (!mpeg2dec->convert_start) + printf("mpeg2dec:header_end:discard_fbuf=b_type+1\n"); + } + } else if (!mpeg2dec->convert_start) { mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type]; + printf("mpeg2dec:header_end:discard_fbuf=b_type\n"); + } mpeg2dec->action = mpeg2_seek_sequence; + printf("mpeg2dec:action = mpeg2_seek_sequence\n"); mpeg2dec->first = 1; return STATE_END; +#endif } + + diff --git a/src/libmpeg2new/libmpeg2/idct.c b/src/libmpeg2new/libmpeg2/idct.c index 932efcf2a..57aba175b 100644 --- a/src/libmpeg2new/libmpeg2/idct.c +++ b/src/libmpeg2new/libmpeg2/idct.c @@ -26,9 +26,9 @@ #include <stdlib.h> #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "attributes.h" +#include "../include/attributes.h" #define W1 2841 /* 2048 * sqrt (2) * cos (1 * pi / 16) */ #define W2 2676 /* 2048 * sqrt (2) * cos (2 * pi / 16) */ diff --git a/src/libmpeg2new/libmpeg2/idct_altivec.c b/src/libmpeg2new/libmpeg2/idct_altivec.c index e9fc28bc4..d8f3ceab0 100644 --- a/src/libmpeg2new/libmpeg2/idct_altivec.c +++ b/src/libmpeg2new/libmpeg2/idct_altivec.c @@ -30,9 +30,9 @@ #endif #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "attributes.h" +#include "../include/attributes.h" typedef vector signed char vector_s8_t; typedef vector unsigned char vector_u8_t; diff --git a/src/libmpeg2new/libmpeg2/idct_mlib.c b/src/libmpeg2new/libmpeg2/idct_mlib.c index 83c39738d..e8f321a83 100644 --- a/src/libmpeg2new/libmpeg2/idct_mlib.c +++ b/src/libmpeg2new/libmpeg2/idct_mlib.c @@ -31,7 +31,7 @@ #include <string.h> #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" void mpeg2_idct_add_mlib (const int last, int16_t * const block, diff --git a/src/libmpeg2new/libmpeg2/idct_mmx.c b/src/libmpeg2new/libmpeg2/idct_mmx.c index e2afe6bb4..c0e88f220 100644 --- a/src/libmpeg2new/libmpeg2/idct_mmx.c +++ b/src/libmpeg2new/libmpeg2/idct_mmx.c @@ -27,10 +27,10 @@ #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "attributes.h" -#include "mmx.h" +#include "../include/attributes.h" +#include "../include/mmx.h" #define ROW_SHIFT 11 #define COL_SHIFT 6 diff --git a/src/libmpeg2new/libmpeg2/motion_comp.c b/src/libmpeg2new/libmpeg2/motion_comp.c index 24cfee1e1..cf9f807e2 100644 --- a/src/libmpeg2new/libmpeg2/motion_comp.c +++ b/src/libmpeg2new/libmpeg2/motion_comp.c @@ -25,7 +25,7 @@ #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" mpeg2_mc_t mpeg2_mc; diff --git a/src/libmpeg2new/libmpeg2/motion_comp_alpha.c b/src/libmpeg2new/libmpeg2/motion_comp_alpha.c index 662221b4d..efa0c44af 100644 --- a/src/libmpeg2new/libmpeg2/motion_comp_alpha.c +++ b/src/libmpeg2new/libmpeg2/motion_comp_alpha.c @@ -26,9 +26,9 @@ #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "alpha_asm.h" +#include "../include/alpha_asm.h" static inline uint64_t avg2 (uint64_t a, uint64_t b) { diff --git a/src/libmpeg2new/libmpeg2/motion_comp_altivec.c b/src/libmpeg2new/libmpeg2/motion_comp_altivec.c index f5d884e6e..f0b6fa691 100644 --- a/src/libmpeg2new/libmpeg2/motion_comp_altivec.c +++ b/src/libmpeg2new/libmpeg2/motion_comp_altivec.c @@ -30,7 +30,7 @@ #endif #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" typedef vector signed char vector_s8_t; diff --git a/src/libmpeg2new/libmpeg2/motion_comp_mlib.c b/src/libmpeg2new/libmpeg2/motion_comp_mlib.c index c7ed6b285..96f000991 100644 --- a/src/libmpeg2new/libmpeg2/motion_comp_mlib.c +++ b/src/libmpeg2new/libmpeg2/motion_comp_mlib.c @@ -30,7 +30,7 @@ #include <mlib_video.h> #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" static void MC_put_o_16_mlib (uint8_t * dest, const uint8_t * ref, diff --git a/src/libmpeg2new/libmpeg2/motion_comp_mmx.c b/src/libmpeg2new/libmpeg2/motion_comp_mmx.c index 2434ccee1..fc8e83abc 100644 --- a/src/libmpeg2new/libmpeg2/motion_comp_mmx.c +++ b/src/libmpeg2new/libmpeg2/motion_comp_mmx.c @@ -27,10 +27,10 @@ #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "attributes.h" -#include "mmx.h" +#include "../include/attributes.h" +#include "../include/mmx.h" #define CPU_MMXEXT 0 #define CPU_3DNOW 1 diff --git a/src/libmpeg2new/libmpeg2/slice.c b/src/libmpeg2new/libmpeg2/slice.c index 3e2db0803..095fc4c82 100644 --- a/src/libmpeg2new/libmpeg2/slice.c +++ b/src/libmpeg2new/libmpeg2/slice.c @@ -25,9 +25,9 @@ #include <inttypes.h> -#include "mpeg2.h" +#include "../include/mpeg2.h" #include "mpeg2_internal.h" -#include "attributes.h" +#include "../include/attributes.h" extern mpeg2_mc_t mpeg2_mc; extern void (* mpeg2_idct_copy) (int16_t * block, uint8_t * dest, int stride); @@ -1469,9 +1469,15 @@ void mpeg2_init_fbuf (mpeg2_decoder_t * decoder, uint8_t * current_fbuf[3], decoder->picture_dest[1] = current_fbuf[1] + (offset >> 1); decoder->picture_dest[2] = current_fbuf[2] + (offset >> 1); - decoder->f_motion.ref[0][0] = forward_fbuf[0] + offset; - decoder->f_motion.ref[0][1] = forward_fbuf[1] + (offset >> 1); - decoder->f_motion.ref[0][2] = forward_fbuf[2] + (offset >> 1); + if (forward_fbuf) { + decoder->f_motion.ref[0][0] = forward_fbuf[0] + offset; + decoder->f_motion.ref[0][1] = forward_fbuf[1] + (offset >> 1); + decoder->f_motion.ref[0][2] = forward_fbuf[2] + (offset >> 1); + } else { + decoder->f_motion.ref[0][0] = 0; + decoder->f_motion.ref[0][1] = 0; + decoder->f_motion.ref[0][2] = 0; + } decoder->b_motion.ref[0][0] = backward_fbuf[0] + offset; decoder->b_motion.ref[0][1] = backward_fbuf[1] + (offset >> 1); @@ -1488,9 +1494,15 @@ void mpeg2_init_fbuf (mpeg2_decoder_t * decoder, uint8_t * current_fbuf[3], if (decoder->second_field && (decoder->coding_type != B_TYPE)) forward_fbuf = current_fbuf; - decoder->f_motion.ref[1][0] = forward_fbuf[0] + offset; - decoder->f_motion.ref[1][1] = forward_fbuf[1] + (offset >> 1); - decoder->f_motion.ref[1][2] = forward_fbuf[2] + (offset >> 1); + if (forward_fbuf) { + decoder->f_motion.ref[1][0] = forward_fbuf[0] + offset; + decoder->f_motion.ref[1][1] = forward_fbuf[1] + (offset >> 1); + decoder->f_motion.ref[1][2] = forward_fbuf[2] + (offset >> 1); + } else { + decoder->f_motion.ref[0][0] = 0; + decoder->f_motion.ref[0][1] = 0; + decoder->f_motion.ref[0][2] = 0; + } decoder->b_motion.ref[1][0] = backward_fbuf[0] + offset; decoder->b_motion.ref[1][1] = backward_fbuf[1] + (offset >> 1); diff --git a/src/libmpeg2new/xine_decoder.c b/src/libmpeg2new/xine_decoder.c index 8d0445898..5b78782a8 100644 --- a/src/libmpeg2new/xine_decoder.c +++ b/src/libmpeg2new/xine_decoder.c @@ -17,7 +17,7 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA * - * $Id: xine_decoder.c,v 1.4 2003/06/11 00:22:57 jcdutton Exp $ + * $Id: xine_decoder.c,v 1.5 2003/06/13 00:52:47 jcdutton Exp $ * * stuff needed to turn libmpeg2 into a xine decoder plugin */ @@ -30,18 +30,18 @@ #include <fcntl.h> #include <unistd.h> #include <inttypes.h> -#include <mpeg2dec/mpeg2.h> #include <assert.h> +#include "./include/mpeg2.h" #include "xine_internal.h" #include "video_out.h" #include "buffer.h" #define LOG -/* + #define LOG_FRAME_ALLOC_FREE -*/ + typedef struct { video_decoder_class_t decoder_class; @@ -53,8 +53,44 @@ typedef struct mpeg2_video_decoder_s { mpeg2dec_t *mpeg2dec; mpeg2_class_t *class; xine_stream_t *stream; + int32_t force_aspect; + int32_t aspect_ratio; + int32_t aspect_ratio_float; + uint32_t img_state[30]; + uint32_t frame_number; + } mpeg2_video_decoder_t; + +static void mpeg2_video_print_bad_state(uint32_t * img_state) { + int32_t n,m; + m=0; + for(n=0;n<30;n++) { + if (img_state[n]>0) { + printf("%d = %u\n",n, img_state[n]); + m++; + } + } + if (m > 3) assert(0); + if (m == 0) printf("NO FRAMES\n"); +} + +static void mpeg2_video_print_fbuf(const mpeg2_fbuf_t * fbuf) { + printf("%p",fbuf); + vo_frame_t * img; + if (fbuf) { + img = (vo_frame_t *) fbuf->id; + if (img) { + printf (", img=%p, (id=%d)\n", + img, img->id); + } else { + printf (", img=NULL\n"); + } + } else { + printf ("\n"); + } +} + static void mpeg2_video_decode_data (video_decoder_t *this_gen, buf_element_t *buf_element) { mpeg2_video_decoder_t *this = (mpeg2_video_decoder_t *) this_gen; uint8_t * current = buf_element->content; @@ -63,76 +99,198 @@ static void mpeg2_video_decode_data (video_decoder_t *this_gen, buf_element_t *b uint32_t pts; mpeg2_state_t state; vo_frame_t * img; + /* handle aspect hints from xine-dvdnav */ + if (buf_element->decoder_flags & BUF_FLAG_SPECIAL) { + if (buf_element->decoder_info[1] == BUF_SPECIAL_ASPECT) { + this->force_aspect = buf_element->decoder_info[2]; + if (buf_element->decoder_info[3] == 0x1 && buf_element->decoder_info[2] == XINE_VO_ASPECT_ANAMORPHIC) + /* letterboxing is denied, we have to do pan&scan */ + this->force_aspect = XINE_VO_ASPECT_PAN_SCAN; + } + printf("libmpeg2:decode_data: forced aspect to=%d\n", this->force_aspect); + + return; + } + if (buf_element->decoder_flags != 0) return; + + printf ("libmpeg2:decode_data:buffer\n"); pts=buf_element->pts; mpeg2_buffer (this->mpeg2dec, current, end); info = mpeg2_info (this->mpeg2dec); while ((state = mpeg2_parse (this->mpeg2dec)) != STATE_BUFFER) { + printf("libmpeg2:decode_data:current_fbuf="); + mpeg2_video_print_fbuf(info->current_fbuf); + printf("libmpeg2:decode_data:display_fbuf="); + mpeg2_video_print_fbuf(info->display_fbuf); + printf("libmpeg2:decode_data:discard_fbuf="); + mpeg2_video_print_fbuf(info->discard_fbuf); + switch (state) { case STATE_SEQUENCE: /* might set nb fbuf, convert format, stride */ /* might set fbufs */ - mpeg2_custom_fbuf (this->mpeg2dec, 1); /* <- Force libmpeg2 to use xine frame buffers. */ + printf ("libmpeg2:decode_data:STATE_SEQUENCE\n"); this->stream->stream_info[XINE_STREAM_INFO_VIDEO_WIDTH] = info->sequence->picture_width; this->stream->stream_info[XINE_STREAM_INFO_VIDEO_HEIGHT] = info->sequence->picture_height; this->stream->stream_info[XINE_STREAM_INFO_FRAME_DURATION] = info->sequence->frame_period / 300; - switch (info->sequence->pixel_width) { - case XINE_VO_ASPECT_PAN_SCAN: - case XINE_VO_ASPECT_ANAMORPHIC: - this->stream->stream_info[XINE_STREAM_INFO_VIDEO_RATIO] = 10000 * 16.0 /9.0; - break; - case XINE_VO_ASPECT_DVB: /* 2.11:1 */ - this->stream->stream_info[XINE_STREAM_INFO_VIDEO_RATIO] = 10000 * 2.11/1.0; - break; - case XINE_VO_ASPECT_SQUARE: /* square pels */ - this->stream->stream_info[XINE_STREAM_INFO_VIDEO_RATIO] = 10000; - break; - default: - this->stream->stream_info[XINE_STREAM_INFO_VIDEO_RATIO] = 10000 * 4.0 / 3.0; - break; + if (this->force_aspect > 0) { + this->aspect_ratio = this->force_aspect; + switch (info->sequence->pixel_width) { + case XINE_VO_ASPECT_PAN_SCAN: + case XINE_VO_ASPECT_ANAMORPHIC: + this->aspect_ratio_float = 10000 * 16.0 /9.0; + break; + case XINE_VO_ASPECT_DVB: /* 2.11:1 */ + this->aspect_ratio_float = 10000 * 2.11/1.0; + break; + case XINE_VO_ASPECT_SQUARE: /* square pels */ + this->aspect_ratio_float = 10000; + break; + default: + this->aspect_ratio_float = 10000 * 4.0 / 3.0; + break; + } + } else { + this->aspect_ratio_float = (10000 * info->sequence->pixel_width) / info->sequence->pixel_height; + printf("libmpeg2:decode_data: pixel_width=%d, height=%d\n", + info->sequence->pixel_width, + info->sequence->pixel_height); + if (this->aspect_ratio_float > 20000) { + this->aspect_ratio = XINE_VO_ASPECT_DVB; + } else if (this->aspect_ratio_float > 15000) { + this->aspect_ratio = XINE_VO_ASPECT_ANAMORPHIC; + } else if (this->aspect_ratio_float > 12000) { + this->aspect_ratio = XINE_VO_ASPECT_4_3; + } else { + this->aspect_ratio = XINE_VO_ASPECT_SQUARE; + } } - this->stream->meta_info[XINE_META_INFO_VIDEOCODEC] = strdup ("MPEG-new"); + this->stream->stream_info[XINE_STREAM_INFO_VIDEO_RATIO] = this->aspect_ratio_float; + + + if (info->sequence->flags & SEQ_FLAG_MPEG2) { + this->stream->meta_info[XINE_META_INFO_VIDEOCODEC] = strdup ("MPEG 2 (libmpeg2new)"); + } else { + this->stream->meta_info[XINE_META_INFO_VIDEOCODEC] = strdup ("MPEG 1 (libmpeg2new)"); + } + break; case STATE_PICTURE: /* might skip */ /* might set fbuf */ - + printf ("libmpeg2:decode_data:STATE_PICTURE\n"); + if (info->current_picture) { + printf ("libmpeg2:decode_data:current picture nb_fields = %d, flags = %x type = %d\n", + info->current_picture->nb_fields, + info->current_picture->flags, + info->current_picture->flags & 7); + } + if (info->current_picture_2nd) { + printf ("libmpeg2:decode_data:current2 picture nb_fields = %d, flags = %x\n", + info->current_picture_2nd->nb_fields, + info->current_picture_2nd->flags); + } + if (info->display_picture) { + printf ("libmpeg2:decode_data:display picture nb_fields = %d, flags = %x\n", + info->display_picture->nb_fields, + info->display_picture->flags); + } + if (info->display_picture_2nd) { + printf ("libmpeg2:decode_data:display2 picture nb_fields = %d, flags = %x\n", + info->display_picture_2nd->nb_fields, + info->display_picture_2nd->flags); + } img = this->stream->video_out->get_frame (this->stream->video_out, info->sequence->picture_width, info->sequence->picture_height, - info->sequence->pixel_width, /* Aspect ratio */ + this->aspect_ratio, /* Aspect ratio */ XINE_IMGFMT_YV12, //picture->picture_structure); 0); - img->pts=buf_element->pts; + this->frame_number++; + printf("libmpeg2:frame_number=%u\n",this->frame_number); + //img->pts=buf_element->pts; #ifdef LOG_FRAME_ALLOC_FREE - printf ("libmpeg2:decode_data:get_frame id=%d\n", img->id); + printf ("libmpeg2:decode_data:get_frame %p (id=%d)\n", img,img->id); #endif + if (this->img_state[img->id] != 0) { + printf ("libmpeg2:decode_data:get_frame id=%d BAD STATE:%d\n", img->id, this->img_state[img->id]); + assert(0); + } + + this->img_state[img->id] = 1; mpeg2_set_buf (this->mpeg2dec, img->base, img); break; case STATE_SLICE: case STATE_END: + printf ("libmpeg2:decode_data:STATE_SLICE/END\n"); /* draw current picture */ /* might free frame buffer */ - if (info->display_fbuf) { + if (info->current_picture) { + printf ("libmpeg2:decode_data:current picture nb_fields = %d, flags = %x type = %d\n", + info->current_picture->nb_fields, + info->current_picture->flags, + info->current_picture->flags & 7); + } + if (info->current_picture_2nd) { + printf ("libmpeg2:decode_data:current2 picture nb_fields = %d, flags = %x\n", + info->current_picture_2nd->nb_fields, + info->current_picture_2nd->flags); + } + if (info->display_picture) { + printf ("libmpeg2:decode_data:display picture nb_fields = %d, flags = %x\n", + info->display_picture->nb_fields, + info->display_picture->flags); + } + if (info->display_picture_2nd) { + printf ("libmpeg2:decode_data:display2 picture nb_fields = %d, flags = %x\n", + info->display_picture_2nd->nb_fields, + info->display_picture_2nd->flags); + } + if (info->display_fbuf && info->display_fbuf->id) { img = (vo_frame_t *) info->display_fbuf->id; img->duration=info->sequence->frame_period / 300; #ifdef LOG_FRAME_ALLOC_FREE - printf ("libmpeg2:decode_data:draw_frame id=%d\n", img->id); + printf ("libmpeg2:decode_data:draw_frame %p, id=%d \n", info->display_fbuf, img->id); #endif - img->draw (img, this->stream); + if (this->img_state[img->id] != 1) { + printf ("libmpeg2:decode_data:draw_frame id=%d BAD STATE:%d\n", img->id, this->img_state[img->id]); + assert(0); + } + if (this->img_state[img->id] == 1) { + img->draw (img, this->stream); + this->img_state[img->id] = 2; + } + + } + if (info->discard_fbuf && !info->discard_fbuf->id) { + printf ("libmpeg2:decode_data:BAD free_frame discard_fbuf=%p\n", info->discard_fbuf); + assert(0); } - img = (vo_frame_t *) info->discard_fbuf->id; - if (info->discard_fbuf && img) { + if (info->discard_fbuf && info->discard_fbuf->id) { + img = (vo_frame_t *) info->discard_fbuf->id; #ifdef LOG_FRAME_ALLOC_FREE - printf ("libmpeg2:decode_data:free_frame id=%d\n", img->id); + printf ("libmpeg2:decode_data:free_frame %p,id=%d\n", info->discard_fbuf, img->id); #endif - img->free(img); + if (this->img_state[img->id] != 2) { + printf ("libmpeg2:decode_data:free_frame id=%d BAD STATE:%d\n", img->id, this->img_state[img->id]); + assert(0); + } + if (this->img_state[img->id] == 2) { + img->free(img); + this->img_state[img->id] = 0; + } } + mpeg2_video_print_bad_state(this->img_state); + break; + case STATE_GOP: + printf ("libmpeg2:decode_data:STATE_GOP\n"); break; default: + printf ("libmpeg2:decode_data:UNKNOWN STATE!!!=%d\n", state); break; } @@ -185,6 +343,7 @@ static void mpeg2_video_dispose (video_decoder_t *this_gen) { static video_decoder_t *open_plugin (video_decoder_class_t *class_gen, xine_stream_t *stream) { mpeg2_video_decoder_t *this ; + int32_t n; this = (mpeg2_video_decoder_t *) malloc (sizeof (mpeg2_video_decoder_t)); memset(this, 0, sizeof (mpeg2_video_decoder_t)); @@ -196,10 +355,13 @@ static video_decoder_t *open_plugin (video_decoder_class_t *class_gen, xine_stre this->video_decoder.dispose = mpeg2_video_dispose; this->stream = stream; this->class = (mpeg2_class_t *) class_gen; + this->frame_number=0; this->mpeg2dec = mpeg2_init (); + mpeg2_custom_fbuf (this->mpeg2dec, 1); /* <- Force libmpeg2 to use xine frame buffers. */ stream->video_out->open(stream->video_out, stream); -/* this->mpeg2.force_aspect = 0; */ + this->force_aspect = 0; + for(n=0;n<30;n++) this->img_state[n]=0; return &this->video_decoder; } |