From a6b05cacbf52dd3b3b7aa4974d81e2221e203097 Mon Sep 17 00:00:00 2001 From: James Courtier-Dutton Date: Fri, 13 Jun 2003 00:52:47 +0000 Subject: Some updates. We now use our own version of libmpeg2 version 0.3.2. Once we have it working 100% we will look at sending patches to the libmpeg2 list. Lots of debug info it currently in the code. It will be removed once it is working. Currently working: - 1) All frames allocated and freed correctly. Fixing that took a long time. 2) It seems that we do not need any of the flush, discontinuity or reset calls yet. Adding seeking might change that. The reason for this is that we properly support sequence end information, so still images get displayed immeadiately. TODO: - 1) Picture info needs to be fixed. I.E. Check that the correct picture info matchs the image buffer. 2) Closed captions. Implement the closed caption decoder. 3) PTS info. 4) extra info. 5) Seeking. 6) Repeat first field pattern sensing. 7) Picture coding type. E.g. Frame, Fields, RFF etc. using in the get_frame call. CVS patchset: 5031 CVS date: 2003/06/13 00:52:47 --- src/libmpeg2new/Makefile.am | 4 +- src/libmpeg2new/include/Makefile.am | 3 + src/libmpeg2new/include/alpha_asm.h | 181 +++++++++++++++++ src/libmpeg2new/include/attributes.h | 37 ++++ src/libmpeg2new/include/config.h | 161 +++++++++++++++ src/libmpeg2new/include/config.h.in | 160 +++++++++++++++ src/libmpeg2new/include/convert.h | 56 ++++++ src/libmpeg2new/include/mmx.h | 263 +++++++++++++++++++++++++ src/libmpeg2new/include/mpeg2.h | 166 ++++++++++++++++ src/libmpeg2new/include/sse.h | 256 ++++++++++++++++++++++++ src/libmpeg2new/include/stamp-h1 | 1 + src/libmpeg2new/include/tendra.h | 35 ++++ src/libmpeg2new/include/video_out.h | 53 +++++ src/libmpeg2new/libmpeg2/Makefile.am | 25 ++- src/libmpeg2new/libmpeg2/alloc.c | 2 +- src/libmpeg2new/libmpeg2/cpu_accel.c | 2 +- src/libmpeg2new/libmpeg2/cpu_state.c | 6 +- src/libmpeg2new/libmpeg2/decode.c | 100 +++++++++- src/libmpeg2new/libmpeg2/header.c | 128 ++++++++++-- src/libmpeg2new/libmpeg2/idct.c | 4 +- src/libmpeg2new/libmpeg2/idct_altivec.c | 4 +- src/libmpeg2new/libmpeg2/idct_mlib.c | 2 +- src/libmpeg2new/libmpeg2/idct_mmx.c | 6 +- src/libmpeg2new/libmpeg2/motion_comp.c | 2 +- src/libmpeg2new/libmpeg2/motion_comp_alpha.c | 4 +- src/libmpeg2new/libmpeg2/motion_comp_altivec.c | 2 +- src/libmpeg2new/libmpeg2/motion_comp_mlib.c | 2 +- src/libmpeg2new/libmpeg2/motion_comp_mmx.c | 6 +- src/libmpeg2new/libmpeg2/slice.c | 28 ++- src/libmpeg2new/xine_decoder.c | 226 ++++++++++++++++++--- 30 files changed, 1831 insertions(+), 94 deletions(-) create mode 100644 src/libmpeg2new/include/Makefile.am create mode 100644 src/libmpeg2new/include/alpha_asm.h create mode 100644 src/libmpeg2new/include/attributes.h create mode 100644 src/libmpeg2new/include/config.h create mode 100644 src/libmpeg2new/include/config.h.in create mode 100644 src/libmpeg2new/include/convert.h create mode 100644 src/libmpeg2new/include/mmx.h create mode 100644 src/libmpeg2new/include/mpeg2.h create mode 100644 src/libmpeg2new/include/sse.h create mode 100644 src/libmpeg2new/include/stamp-h1 create mode 100644 src/libmpeg2new/include/tendra.h create mode 100644 src/libmpeg2new/include/video_out.h (limited to 'src') 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 + * + * 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 + +#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 +#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 + * Copyright (C) 1999-2000 Aaron Holtzman + * + * 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 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 header file. */ +/* #undef HAVE_DDRAW_H */ + +/* Define to 1 if you have the 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 header file. */ +/* #undef HAVE_INTTYPES_H */ + +/* Define to 1 if you have the 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 header file. */ +/* #undef HAVE_MEMORY_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_STDINT_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_STDLIB_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_STRINGS_H */ + +/* Define to 1 if you have the 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 header file. */ +/* #undef HAVE_SYS_STAT_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TIMEB_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TIME_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_TYPES_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_TIME_H 1 + +/* Define to 1 if you have the 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 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 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 header file. */ +#undef HAVE_DDRAW_H + +/* Define to 1 if you have the 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 header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the 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 header file. */ +#undef HAVE_MEMORY_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the 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 header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TIMEB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TIME_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_TIME_H + +/* Define to 1 if you have the 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 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 + * Copyright (C) 1999-2000 Aaron Holtzman + * + * 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 + * Copyright (C) 1999-2000 Aaron Holtzman + * + * 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 + * Copyright (C) 1999-2000 Aaron Holtzman + * + * 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 + * Copyright (C) 1999-2000 Aaron Holtzman + * + * 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 + * Copyright (C) 1999-2000 Aaron Holtzman + * + * 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 #include -#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 -#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 #include -#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 /* For testing printf */ #include /* memcmp/memset, try to remove */ #include #include -#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 /* For printf */ #include #include /* defines NULL */ #include /* memcmp */ +#include -#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 #include -#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 -#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 #include -#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 -#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 -#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 -#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 -#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 #include -#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 -#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 -#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 #include #include -#include #include +#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; } -- cgit v1.2.3