From 943139cc78038c3aea0837229298cb2c08e3f8a2 Mon Sep 17 00:00:00 2001 From: henry Date: Mon, 2 Aug 2004 11:26:43 +0000 Subject: Importing libmpeg2 from mpeg2dec-0.4.0b git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@12933 b3059339-0415-0410-9bf9-f77b7e298cf2 --- libmpeg2/Makefile | 4 +- libmpeg2/alloc.c | 54 +- libmpeg2/alpha_asm.h | 75 +- libmpeg2/attributes.h | 2 +- libmpeg2/convert.h | 56 -- libmpeg2/cpu_accel.c | 54 +- libmpeg2/cpu_state.c | 4 +- libmpeg2/decode.c | 255 +++-- libmpeg2/header.c | 643 ++++++++----- libmpeg2/idct.c | 95 +- libmpeg2/idct_alpha.c | 75 +- libmpeg2/idct_altivec.c | 128 ++- libmpeg2/idct_mlib.c | 60 -- libmpeg2/idct_mmx.c | 10 +- libmpeg2/mmx.h | 2 +- libmpeg2/motion_comp.c | 7 +- libmpeg2/motion_comp_alpha.c | 198 ++-- libmpeg2/motion_comp_altivec.c | 1 + libmpeg2/motion_comp_mlib.c | 190 ---- libmpeg2/motion_comp_mmx.c | 2 +- libmpeg2/motion_comp_vis.c | 2061 ++++++++++++++++++++++++++++++++++++++++ libmpeg2/mpeg2.h | 136 ++- libmpeg2/mpeg2_internal.h | 144 +-- libmpeg2/slice.c | 1299 +++++++++++++++---------- libmpeg2/vis.h | 328 +++++++ libmpeg2/vlc.h | 87 +- 26 files changed, 4299 insertions(+), 1671 deletions(-) delete mode 100644 libmpeg2/convert.h delete mode 100644 libmpeg2/idct_mlib.c delete mode 100644 libmpeg2/motion_comp_mlib.c create mode 100644 libmpeg2/motion_comp_vis.c create mode 100644 libmpeg2/vis.h (limited to 'libmpeg2') diff --git a/libmpeg2/Makefile b/libmpeg2/Makefile index b7e93d796b..2c4c77b467 100644 --- a/libmpeg2/Makefile +++ b/libmpeg2/Makefile @@ -3,10 +3,10 @@ LIBNAME = libmpeg2.a include ../config.mak -SRCS = alloc.c cpu_accel.c cpu_state.c decode.c header.c idct.c idct_alpha.c idct_mlib.c idct_mmx.c motion_comp.c motion_comp_alpha.c motion_comp_mlib.c motion_comp_mmx.c slice.c +SRCS = alloc.c cpu_accel.c cpu_state.c decode.c header.c idct.c idct_alpha.c idct_mmx.c motion_comp.c motion_comp_alpha.c motion_comp_mmx.c slice.c OBJS = $(SRCS:.c=.o) -INCLUDE = -I. -I../libvo -I.. $(EXTRA_INC) $(MLIB_INC) +INCLUDE = -I. -I../libvo -I.. $(EXTRA_INC) CFLAGS = $(OPTFLAGS) $(INCLUDE) -DMPG12PLAY ifeq ($(TARGET_ALTIVEC),yes) diff --git a/libmpeg2/alloc.c b/libmpeg2/alloc.c index 2e4792e94d..0698937bce 100644 --- a/libmpeg2/alloc.c +++ b/libmpeg2/alloc.c @@ -21,56 +21,50 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include "config.h" - #include #include #include "mpeg2.h" -#include "mpeg2_internal.h" - -#if defined(HAVE_MEMALIGN) && !defined(__cplusplus) -/* some systems have memalign() but no declaration for it */ -void * memalign (size_t align, size_t size); -#endif -void * (* mpeg2_malloc_hook) (int size, int reason) = NULL; -int (* mpeg2_free_hook) (void * buf) = NULL; +static void * (* malloc_hook) (unsigned size, mpeg2_alloc_t reason) = NULL; +static int (* free_hook) (void * buf) = NULL; -void * mpeg2_malloc (int size, int reason) +void * mpeg2_malloc (unsigned size, mpeg2_alloc_t reason) { char * buf; - if (mpeg2_malloc_hook) { - buf = (char *) mpeg2_malloc_hook (size, reason); + if (malloc_hook) { + buf = (char *) malloc_hook (size, reason); if (buf) return buf; } -#if defined(HAVE_MEMALIGN) && !defined(__cplusplus) && !defined(DEBUG) - return memalign (16, size); -#else - buf = (char *) malloc (size + 15 + sizeof (void **)); - if (buf) { - char * align_buf; + if (size) { + buf = (char *) malloc (size + 63 + sizeof (void **)); + if (buf) { + char * align_buf; - align_buf = buf + 15 + sizeof (void **); - align_buf -= (long)align_buf & 15; - *(((void **)align_buf) - 1) = buf; - return align_buf; + align_buf = buf + 63 + sizeof (void **); + align_buf -= (long)align_buf & 63; + *(((void **)align_buf) - 1) = buf; + return align_buf; + } } return NULL; -#endif } void mpeg2_free (void * buf) { - if (mpeg2_free_hook && mpeg2_free_hook (buf)) + if (free_hook && free_hook (buf)) return; -#if defined(HAVE_MEMALIGN) && !defined(__cplusplus) && !defined(DEBUG) - free (buf); -#else - free (*(((void **)buf) - 1)); -#endif + if (buf) + free (*(((void **)buf) - 1)); +} + +void mpeg2_malloc_hooks (void * malloc (unsigned, mpeg2_alloc_t), + int free (void *)) +{ + malloc_hook = malloc; + free_hook = free; } diff --git a/libmpeg2/alpha_asm.h b/libmpeg2/alpha_asm.h index 6864ccc2e7..bf1081f249 100644 --- a/libmpeg2/alpha_asm.h +++ b/libmpeg2/alpha_asm.h @@ -1,6 +1,6 @@ /* * Alpha assembly macros - * Copyright (c) 2002 Falk Hueffner + * 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. @@ -83,22 +83,11 @@ 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,0) -/* Unfortunately, __builtin_prefetch is slightly buggy on Alpha. The - defines here are kludged so we still get the right - instruction. This needs to be adapted as soon as gcc is fixed. */ -# define prefetch(p) __builtin_prefetch((p), 0, 1) -# define prefetch_en(p) __builtin_prefetch((p), 1, 1) -# define prefetch_m(p) __builtin_prefetch((p), 0, 0) -# define prefetch_men(p) __builtin_prefetch((p), 1, 0) -#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") -#endif - #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)) @@ -109,6 +98,24 @@ struct unaligned_long { uint64_t l; } __attribute__((packed)); #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 @@ -123,30 +130,20 @@ struct unaligned_long { uint64_t l; } __attribute__((packed)); #define unpkbl __builtin_alpha_unpkbl #define unpkbw __builtin_alpha_unpkbw #else -#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; }) -#define minub8(a, b) ({ uint64_t __r; asm ("minub8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -#define minsb8(a, b) ({ uint64_t __r; asm ("minsb8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -#define minuw4(a, b) ({ uint64_t __r; asm ("minuw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -#define minsw4(a, b) ({ uint64_t __r; asm ("minsw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -#define maxub8(a, b) ({ uint64_t __r; asm ("maxub8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -#define maxsb8(a, b) ({ uint64_t __r; asm ("maxsb8 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -#define maxuw4(a, b) ({ uint64_t __r; asm ("maxuw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -#define maxsw4(a, b) ({ uint64_t __r; asm ("maxsw4 %r1,%2,%0" : "=r" (__r) : "%rJ" (a), "rI" (b)); __r; }) -#define perr(a, b) ({ uint64_t __r; asm ("perr %r1,%r2,%0" : "=r" (__r) : "%rJ" (a), "rJ" (b)); __r; }) -#define pklb(a) ({ uint64_t __r; asm ("pklb %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) -#define pkwb(a) ({ uint64_t __r; asm ("pkwb %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) -#define unpkbl(a) ({ uint64_t __r; asm ("unpkbl %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) -#define unpkbw(a) ({ uint64_t __r; asm ("unpkbw %r1,%0" : "=r" (__r) : "rJ" (a)); __r; }) +#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 -#define wh64(p) asm volatile("wh64 (%0)" : : "r"(p) : "memory") #elif defined(__DECC) /* Digital/Compaq/hp "ccc" compiler */ diff --git a/libmpeg2/attributes.h b/libmpeg2/attributes.h index 96a86b26c0..eefbc0dd1b 100644 --- a/libmpeg2/attributes.h +++ b/libmpeg2/attributes.h @@ -1,6 +1,6 @@ /* * attributes.h - * Copyright (C) 2000-2002 Michel Lespinasse + * 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. diff --git a/libmpeg2/convert.h b/libmpeg2/convert.h deleted file mode 100644 index fd51fd84c2..0000000000 --- a/libmpeg2/convert.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * convert.h - * Copyright (C) 2000-2002 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/libmpeg2/cpu_accel.c b/libmpeg2/cpu_accel.c index c2c91e5c0a..e87f5b20a9 100644 --- a/libmpeg2/cpu_accel.c +++ b/libmpeg2/cpu_accel.c @@ -26,6 +26,8 @@ #include #include "mpeg2.h" +#include "attributes.h" +#include "mpeg2_internal.h" #ifdef ACCEL_DETECT #ifdef ARCH_X86 @@ -35,7 +37,7 @@ static inline uint32_t arch_accel (void) int AMD; uint32_t caps; -#ifndef PIC +#if !defined(PIC) && !defined(__PIC__) #define cpuid(op,eax,ebx,ecx,edx) \ __asm__ ("cpuid" \ : "=a" (eax), \ @@ -106,7 +108,7 @@ static inline uint32_t arch_accel (void) } #endif /* ARCH_X86 */ -#ifdef ARCH_PPC +#if defined(ARCH_PPC) || defined(ARCH_SPARC) #include #include @@ -124,6 +126,7 @@ static RETSIGTYPE sigill_handler (int sig) siglongjmp (jmpbuf, 1); } +#ifdef ARCH_PPC static inline uint32_t arch_accel (void) { static RETSIGTYPE (* oldsig) (int); @@ -146,11 +149,49 @@ static inline uint32_t arch_accel (void) : : "r" (-1)); + canjump = 0; + signal (SIGILL, oldsig); return MPEG2_ACCEL_PPC_ALTIVEC; } #endif /* ARCH_PPC */ +#ifdef ARCH_SPARC +static inline uint32_t arch_accel (void) +{ + static RETSIGTYPE (* oldsig) (int); + + oldsig = signal (SIGILL, sigill_handler); + if (sigsetjmp (jmpbuf, 1)) { + signal (SIGILL, oldsig); + return 0; + } + + canjump = 1; + + /* pdist %f0, %f0, %f0 */ + __asm__ __volatile__(".word\t0x81b007c0"); + + canjump = 0; + + if (sigsetjmp (jmpbuf, 1)) { + signal (SIGILL, oldsig); + return MPEG2_ACCEL_SPARC_VIS; + } + + canjump = 1; + + /* edge8n %g0, %g0, %g0 */ + __asm__ __volatile__(".word\t0x81b00020"); + + canjump = 0; + + signal (SIGILL, oldsig); + return MPEG2_ACCEL_SPARC_VIS | MPEG2_ACCEL_SPARC_VIS2; +} +#endif /* ARCH_SPARC */ +#endif /* ARCH_PPC || ARCH_SPARC */ + #ifdef ARCH_ALPHA static inline uint32_t arch_accel (void) { @@ -167,7 +208,7 @@ static inline uint32_t arch_accel (void) #endif } #endif /* ARCH_ALPHA */ -#endif +#endif /* ACCEL_DETECT */ uint32_t mpeg2_detect_accel (void) { @@ -175,11 +216,8 @@ uint32_t mpeg2_detect_accel (void) accel = 0; #ifdef ACCEL_DETECT -#ifdef LIBMPEG2_MLIB - accel = MPEG2_ACCEL_MLIB; -#endif -#if defined (ARCH_X86) || defined (ARCH_PPC) || defined (ARCH_ALPHA) - accel |= arch_accel (); +#if defined (ARCH_X86) || defined (ARCH_PPC) || defined (ARCH_ALPHA) || defined (ARCH_SPARC) + accel = arch_accel (); #endif #endif return accel; diff --git a/libmpeg2/cpu_state.c b/libmpeg2/cpu_state.c index e6544c6904..2a032dec00 100644 --- a/libmpeg2/cpu_state.c +++ b/libmpeg2/cpu_state.c @@ -27,8 +27,8 @@ #include #include "mpeg2.h" -#include "mpeg2_internal.h" #include "attributes.h" +#include "mpeg2_internal.h" #ifdef ARCH_X86 #include "mmx.h" #endif @@ -43,7 +43,7 @@ static void state_restore_mmx (cpu_state_t * state) } #endif -#if defined(ARCH_PPC) && defined(HAVE_ALTIVEC) +#ifdef ARCH_PPC #ifdef HAVE_ALTIVEC_H /* gnu */ #define LI(a,b) "li " #a "," #b "\n\t" #define STVX0(a,b,c) "stvx " #a ",0," #c "\n\t" diff --git a/libmpeg2/decode.c b/libmpeg2/decode.c index fa87a824c1..bba2af4954 100644 --- a/libmpeg2/decode.c +++ b/libmpeg2/decode.c @@ -1,6 +1,6 @@ /* * decode.c - * Copyright (C) 2000-2002 Michel Lespinasse + * 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. @@ -28,8 +28,8 @@ #include #include "mpeg2.h" +#include "attributes.h" #include "mpeg2_internal.h" -#include "convert.h" static int mpeg2_accels = 0; @@ -44,7 +44,6 @@ static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes) { uint8_t * current; uint32_t shift; - uint8_t * chunk_ptr; uint8_t * limit; uint8_t byte; @@ -53,7 +52,6 @@ static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes) current = mpeg2dec->buf_start; shift = mpeg2dec->shift; - chunk_ptr = mpeg2dec->chunk_ptr; limit = current + bytes; do { @@ -116,69 +114,54 @@ void mpeg2_buffer (mpeg2dec_t * mpeg2dec, uint8_t * start, uint8_t * end) mpeg2dec->buf_end = end; } -static inline int seek_chunk (mpeg2dec_t * mpeg2dec) +int mpeg2_getpos (mpeg2dec_t * mpeg2dec) +{ + return mpeg2dec->buf_end - mpeg2dec->buf_start; +} + +static inline mpeg2_state_t seek_chunk (mpeg2dec_t * mpeg2dec) { int size, skipped; size = mpeg2dec->buf_end - mpeg2dec->buf_start; skipped = skip_chunk (mpeg2dec, size); if (!skipped) { - mpeg2dec->bytes_since_pts += size; - return -1; + mpeg2dec->bytes_since_tag += size; + return STATE_BUFFER; } - mpeg2dec->bytes_since_pts += skipped; + mpeg2dec->bytes_since_tag += skipped; mpeg2dec->code = mpeg2dec->buf_start[-1]; - return 0; + return (mpeg2_state_t)-1; } -int mpeg2_seek_header (mpeg2dec_t * mpeg2dec) +mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec) { while (mpeg2dec->code != 0xb3 && ((mpeg2dec->code != 0xb7 && mpeg2dec->code != 0xb8 && - mpeg2dec->code) || mpeg2dec->sequence.width == -1)) - if (seek_chunk (mpeg2dec)) - return -1; + mpeg2dec->code) || mpeg2dec->sequence.width == (unsigned)-1)) + if (seek_chunk (mpeg2dec) == STATE_BUFFER) + return STATE_BUFFER; mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; - return mpeg2_parse_header (mpeg2dec); -} - -int mpeg2_seek_sequence (mpeg2dec_t * mpeg2dec) -{ - mpeg2dec->sequence.width = -1; - return mpeg2_seek_header (mpeg2dec); + mpeg2dec->user_data_len = 0; + return (mpeg2dec->code ? mpeg2_parse_header (mpeg2dec) : + mpeg2_header_picture_start (mpeg2dec)); } #define RECEIVED(code,state) (((state) << 8) + (code)) -int mpeg2_parse (mpeg2dec_t * mpeg2dec) +mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec) { int size_buffer, size_chunk, copied; - if(mpeg2dec->code==0xff){ - // FIXME: we need to resync stream (esp. mpeg2dec-->code) as we - // left parser at 0x1FF last time at the end of prev. chunk. - // Why? mpeg2dec->action is set to mpeg2_header_picture_start, but - // it will call mpeg2_parse_header() too... - // - // following code copied from mpeg2_seek_header(): - while (mpeg2dec->code != 0xb3 && - ((mpeg2dec->code != 0xb7 && mpeg2dec->code != 0xb8 && - mpeg2dec->code) || mpeg2dec->sequence.width == -1)) - if (seek_chunk (mpeg2dec)) - return -1; - mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; - } - if (mpeg2dec->action) { - int state; + mpeg2_state_t state; state = mpeg2dec->action (mpeg2dec); - if (state) + if ((int)state >= 0) return state; } - + while (1) { - //printf("code=0x%X \n",mpeg2dec->code); while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) < mpeg2dec->nb_decode_slices) { size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; @@ -187,20 +170,20 @@ int mpeg2_parse (mpeg2dec_t * mpeg2dec) if (size_buffer <= size_chunk) { copied = copy_chunk (mpeg2dec, size_buffer); if (!copied) { - mpeg2dec->bytes_since_pts += size_buffer; + mpeg2dec->bytes_since_tag += size_buffer; mpeg2dec->chunk_ptr += size_buffer; - return -1; + return STATE_BUFFER; } } else { copied = copy_chunk (mpeg2dec, size_chunk); if (!copied) { /* filled the chunk buffer without finding a start code */ - mpeg2dec->bytes_since_pts += size_chunk; + mpeg2dec->bytes_since_tag += size_chunk; mpeg2dec->action = seek_chunk; return STATE_INVALID; } } - mpeg2dec->bytes_since_pts += copied; + mpeg2dec->bytes_since_tag += copied; mpeg2_slice (&(mpeg2dec->decoder), mpeg2dec->code, mpeg2dec->chunk_start); @@ -209,37 +192,29 @@ int mpeg2_parse (mpeg2dec_t * mpeg2dec) } if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1) break; - if (seek_chunk (mpeg2dec)) - return -1; - } - - //printf("next_code=0x%X state=%d \n",mpeg2dec->code,mpeg2dec->state); - - if(mpeg2dec->code==0xff){ - mpeg2dec->action = mpeg2_header_picture_start; //mpeg2_seek_header; - return mpeg2dec->state; + if (seek_chunk (mpeg2dec) == STATE_BUFFER) + return STATE_BUFFER; } - switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) { - case RECEIVED (0x00, STATE_SLICE_1ST): - case RECEIVED (0x00, STATE_SLICE): + switch (mpeg2dec->code) { + case 0x00: mpeg2dec->action = mpeg2_header_picture_start; - break; - case RECEIVED (0xb7, STATE_SLICE): + return mpeg2dec->state; + case 0xb7: mpeg2dec->action = mpeg2_header_end; break; - case RECEIVED (0xb3, STATE_SLICE): - case RECEIVED (0xb8, STATE_SLICE): + case 0xb3: + case 0xb8: mpeg2dec->action = mpeg2_parse_header; break; default: - mpeg2dec->action = mpeg2_seek_header; + mpeg2dec->action = seek_chunk; return STATE_INVALID; } - return mpeg2dec->state; + return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID; } -int mpeg2_parse_header (mpeg2dec_t * mpeg2dec) +mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) { static int (* process_header[]) (mpeg2dec_t * mpeg2dec) = { mpeg2_header_picture, mpeg2_header_extension, mpeg2_header_user_data, @@ -248,6 +223,7 @@ int mpeg2_parse_header (mpeg2dec_t * mpeg2dec) int size_buffer, size_chunk, copied; mpeg2dec->action = mpeg2_parse_header; + mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0; while (1) { size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE - @@ -255,26 +231,21 @@ int mpeg2_parse_header (mpeg2dec_t * mpeg2dec) if (size_buffer <= size_chunk) { copied = copy_chunk (mpeg2dec, size_buffer); if (!copied) { - mpeg2dec->bytes_since_pts += size_buffer; + mpeg2dec->bytes_since_tag += size_buffer; mpeg2dec->chunk_ptr += size_buffer; - return -1; + return STATE_BUFFER; } } else { copied = copy_chunk (mpeg2dec, size_chunk); if (!copied) { /* filled the chunk buffer without finding a start code */ - mpeg2dec->bytes_since_pts += size_chunk; + mpeg2dec->bytes_since_tag += size_chunk; mpeg2dec->code = 0xb4; mpeg2dec->action = mpeg2_seek_header; return STATE_INVALID; } } - mpeg2dec->bytes_since_pts += copied; - - //printf("header_code=0x%X state=%d \n",mpeg2dec->code,mpeg2dec->state); - -// if(!mpeg2dec->code && mpeg2dec->state==7) - + mpeg2dec->bytes_since_tag += copied; if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) { mpeg2dec->code = mpeg2dec->buf_start[-1]; @@ -283,9 +254,6 @@ int mpeg2_parse_header (mpeg2dec_t * mpeg2dec) } mpeg2dec->code = mpeg2dec->buf_start[-1]; - - //printf("next_header_code=0x%X state=%d \n",mpeg2dec->code,mpeg2dec->state); - switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) { /* state transition after a sequence header */ @@ -297,10 +265,12 @@ int mpeg2_parse_header (mpeg2dec_t * mpeg2dec) /* other legal state transitions */ case RECEIVED (0x00, STATE_GOP): + mpeg2_header_gop_finalize (mpeg2dec); mpeg2dec->action = mpeg2_header_picture_start; break; case RECEIVED (0x01, STATE_PICTURE): case RECEIVED (0x01, STATE_PICTURE_2ND): + mpeg2_header_picture_finalize (mpeg2dec, mpeg2_accels); mpeg2dec->action = mpeg2_header_slice_start; break; @@ -321,56 +291,58 @@ int mpeg2_parse_header (mpeg2dec_t * mpeg2dec) } mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; + mpeg2dec->user_data_len = 0; return mpeg2dec->state; } } -void mpeg2_convert (mpeg2dec_t * mpeg2dec, - void (* convert) (int, int, uint32_t, void *, - struct convert_init_s *), void * arg) +int mpeg2_convert (mpeg2dec_t * mpeg2dec, mpeg2_convert_t convert, void * arg) { - convert_init_t convert_init; - int size; - - convert_init.id = NULL; - convert (mpeg2dec->decoder.width, mpeg2dec->decoder.height, - mpeg2_accels, arg, &convert_init); - if (convert_init.id_size) { - convert_init.id = mpeg2dec->convert_id = - mpeg2_malloc (convert_init.id_size, ALLOC_CONVERT_ID); - convert (mpeg2dec->decoder.width, mpeg2dec->decoder.height, - mpeg2_accels, arg, &convert_init); + mpeg2_convert_init_t convert_init; + int error; + + error = convert (MPEG2_CONVERT_SET, NULL, &(mpeg2dec->sequence), 0, + mpeg2_accels, arg, &convert_init); + if (!error) { + mpeg2dec->convert = convert; + mpeg2dec->convert_arg = arg; + mpeg2dec->convert_id_size = convert_init.id_size; + mpeg2dec->convert_stride = 0; } - mpeg2dec->convert_size[0] = size = convert_init.buf_size[0]; - mpeg2dec->convert_size[1] = size += convert_init.buf_size[1]; - mpeg2dec->convert_size[2] = size += convert_init.buf_size[2]; - mpeg2dec->convert_start = convert_init.start; - mpeg2dec->convert_copy = convert_init.copy; - - size = mpeg2dec->decoder.width * mpeg2dec->decoder.height >> 2; - mpeg2dec->yuv_buf[0][0] = (uint8_t *) mpeg2_malloc (6 * size, ALLOC_YUV); - mpeg2dec->yuv_buf[0][1] = mpeg2dec->yuv_buf[0][0] + 4 * size; - mpeg2dec->yuv_buf[0][2] = mpeg2dec->yuv_buf[0][0] + 5 * size; - mpeg2dec->yuv_buf[1][0] = (uint8_t *) mpeg2_malloc (6 * size, ALLOC_YUV); - mpeg2dec->yuv_buf[1][1] = mpeg2dec->yuv_buf[1][0] + 4 * size; - mpeg2dec->yuv_buf[1][2] = mpeg2dec->yuv_buf[1][0] + 5 * size; - size = mpeg2dec->decoder.width * 8; - mpeg2dec->yuv_buf[2][0] = (uint8_t *) mpeg2_malloc (6 * size, ALLOC_YUV); - mpeg2dec->yuv_buf[2][1] = mpeg2dec->yuv_buf[2][0] + 4 * size; - mpeg2dec->yuv_buf[2][2] = mpeg2dec->yuv_buf[2][0] + 5 * size; + return error; +} + +int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride) +{ + if (!mpeg2dec->convert) { + if (stride < (int) mpeg2dec->sequence.width) + stride = mpeg2dec->sequence.width; + mpeg2dec->decoder.stride_frame = stride; + } else { + mpeg2_convert_init_t convert_init; + + stride = mpeg2dec->convert (MPEG2_CONVERT_STRIDE, NULL, + &(mpeg2dec->sequence), stride, + mpeg2_accels, mpeg2dec->convert_arg, + &convert_init); + mpeg2dec->convert_id_size = convert_init.id_size; + mpeg2dec->convert_stride = stride; + } + return stride; } void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id) { - fbuf_t * fbuf; + mpeg2_fbuf_t * fbuf; if (mpeg2dec->custom_fbuf) { - mpeg2_set_fbuf (mpeg2dec, mpeg2dec->decoder.coding_type); - fbuf = mpeg2dec->fbuf[0]; if (mpeg2dec->state == STATE_SEQUENCE) { mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; } + mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type == + PIC_FLAG_CODING_TYPE_B)); + fbuf = mpeg2dec->fbuf[0]; } else { fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf); mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index; @@ -409,12 +381,14 @@ void mpeg2_slice_region (mpeg2dec_t * mpeg2dec, int start, int end) mpeg2dec->nb_decode_slices = end - start; } -void mpeg2_pts (mpeg2dec_t * mpeg2dec, uint32_t pts) +void mpeg2_tag_picture (mpeg2dec_t * mpeg2dec, uint32_t tag, uint32_t tag2) { - mpeg2dec->pts_previous = mpeg2dec->pts_current; - mpeg2dec->pts_current = pts; - mpeg2dec->num_pts++; - mpeg2dec->bytes_since_pts = 0; + mpeg2dec->tag_previous = mpeg2dec->tag_current; + mpeg2dec->tag2_previous = mpeg2dec->tag2_current; + mpeg2dec->tag_current = tag; + mpeg2dec->tag2_current = tag2; + mpeg2dec->num_tags++; + mpeg2dec->bytes_since_tag = 0; } uint32_t mpeg2_accel (uint32_t accel) @@ -430,6 +404,27 @@ uint32_t mpeg2_accel (uint32_t accel) return mpeg2_accels & ~MPEG2_ACCEL_DETECT; } +void mpeg2_reset (mpeg2dec_t * mpeg2dec, int full_reset) +{ + mpeg2dec->buf_start = mpeg2dec->buf_end = NULL; + mpeg2dec->num_tags = 0; + mpeg2dec->shift = 0xffffff00; + mpeg2dec->code = 0xb4; + mpeg2dec->action = mpeg2_seek_header; + mpeg2dec->state = STATE_INVALID; + mpeg2dec->first = 1; + + mpeg2_reset_info(&(mpeg2dec->info)); + mpeg2dec->info.gop = NULL; + mpeg2dec->info.user_data = NULL; + mpeg2dec->info.user_data_len = 0; + if (full_reset) { + mpeg2dec->info.sequence = NULL; + mpeg2_header_state_init (mpeg2dec); + } + +} + mpeg2dec_t * mpeg2_init (void) { mpeg2dec_t * mpeg2dec; @@ -437,43 +432,25 @@ mpeg2dec_t * mpeg2_init (void) mpeg2_accel (MPEG2_ACCEL_DETECT); mpeg2dec = (mpeg2dec_t *) mpeg2_malloc (sizeof (mpeg2dec_t), - ALLOC_MPEG2DEC); + MPEG2_ALLOC_MPEG2DEC); if (mpeg2dec == NULL) return NULL; - memset (mpeg2dec, 0, sizeof (mpeg2dec_t)); + memset (mpeg2dec->decoder.DCTblock, 0, 64 * sizeof (int16_t)); + memset (mpeg2dec->quantizer_matrix, 0, 4 * 64 * sizeof (uint8_t)); mpeg2dec->chunk_buffer = (uint8_t *) mpeg2_malloc (BUFFER_SIZE + 4, - ALLOC_CHUNK); - - mpeg2dec->shift = 0xffffff00; - mpeg2dec->action = mpeg2_seek_sequence; - mpeg2dec->code = 0xb4; - mpeg2dec->first_decode_slice = 1; - mpeg2dec->nb_decode_slices = 0xb0 - 1; - mpeg2dec->convert_id = NULL; + MPEG2_ALLOC_CHUNK); - /* initialize substructures */ - mpeg2_header_state_init (mpeg2dec); + mpeg2dec->sequence.width = (unsigned)-1; + mpeg2_reset (mpeg2dec, 1); return mpeg2dec; } void mpeg2_close (mpeg2dec_t * mpeg2dec) { - int i; - - /* static uint8_t finalizer[] = {0,0,1,0xb4}; */ - /* mpeg2_decode_data (mpeg2dec, finalizer, finalizer+4); */ - + mpeg2_header_state_init (mpeg2dec); mpeg2_free (mpeg2dec->chunk_buffer); - if (!mpeg2dec->custom_fbuf) - for (i = mpeg2dec->alloc_index_user; i < mpeg2dec->alloc_index; i++) - mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]); - if (mpeg2dec->convert_start) - for (i = 0; i < 3; i++) - mpeg2_free (mpeg2dec->yuv_buf[i][0]); - if (mpeg2dec->convert_id) - mpeg2_free (mpeg2dec->convert_id); mpeg2_free (mpeg2dec); } diff --git a/libmpeg2/header.c b/libmpeg2/header.c index 248b2e24e2..8312e9a7d6 100644 --- a/libmpeg2/header.c +++ b/libmpeg2/header.c @@ -1,6 +1,7 @@ /* * header.c - * Copyright (C) 2000-2002 Michel Lespinasse + * Copyright (C) 2000-2003 Michel Lespinasse + * Copyright (C) 2003 Regis Duchesne * Copyright (C) 1999-2000 Aaron Holtzman * * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. @@ -28,9 +29,8 @@ #include /* memcmp */ #include "mpeg2.h" -#include "mpeg2_internal.h" -#include "convert.h" #include "attributes.h" +#include "mpeg2_internal.h" #define SEQ_EXT 2 #define SEQ_DISPLAY_EXT 4 @@ -76,57 +76,93 @@ uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) = { void mpeg2_header_state_init (mpeg2dec_t * mpeg2dec) { - mpeg2dec->decoder.scan = mpeg2_scan_norm; + if (mpeg2dec->sequence.width != (unsigned)-1) { + int i; + + mpeg2dec->sequence.width = (unsigned)-1; + if (!mpeg2dec->custom_fbuf) + for (i = mpeg2dec->alloc_index_user; + i < mpeg2dec->alloc_index; i++) { + mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]); + mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[1]); + mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[2]); + } + if (mpeg2dec->convert_start) + for (i = 0; i < 3; i++) { + mpeg2_free (mpeg2dec->yuv_buf[i][0]); + mpeg2_free (mpeg2dec->yuv_buf[i][1]); + mpeg2_free (mpeg2dec->yuv_buf[i][2]); + } + if (mpeg2dec->decoder.convert_id) + mpeg2_free (mpeg2dec->decoder.convert_id); + } + mpeg2dec->decoder.coding_type = I_TYPE; + mpeg2dec->decoder.convert = NULL; + mpeg2dec->decoder.convert_id = NULL; mpeg2dec->picture = mpeg2dec->pictures; + memset(&mpeg2dec->fbuf_alloc[0].fbuf, 0, sizeof(mpeg2_fbuf_t)); + memset(&mpeg2dec->fbuf_alloc[1].fbuf, 0, sizeof(mpeg2_fbuf_t)); + memset(&mpeg2dec->fbuf_alloc[2].fbuf, 0, sizeof(mpeg2_fbuf_t)); mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf; mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf; mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf; mpeg2dec->first = 1; mpeg2dec->alloc_index = 0; mpeg2dec->alloc_index_user = 0; + mpeg2dec->first_decode_slice = 1; + mpeg2dec->nb_decode_slices = 0xb0 - 1; + mpeg2dec->convert = NULL; + mpeg2dec->convert_start = NULL; + mpeg2dec->custom_fbuf = 0; + mpeg2dec->yuv_index = 0; } -static void reset_info (mpeg2_info_t * info) +void mpeg2_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; - info->user_data = NULL; info->user_data_len = 0; +} + +static void info_user_data (mpeg2dec_t * mpeg2dec) +{ + if (mpeg2dec->user_data_len) { + mpeg2dec->info.user_data = mpeg2dec->chunk_buffer; + mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3; + } } int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec) { uint8_t * buffer = mpeg2dec->chunk_start; - sequence_t * sequence = &(mpeg2dec->new_sequence); - decoder_t * decoder = &(mpeg2dec->decoder); - static unsigned int frame_period[9] = { - 0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000 + mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence); + static unsigned int frame_period[16] = { + 0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000, + /* unofficial: xing 15 fps */ + 1800000, + /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */ + 5400000, 2700000, 2250000, 1800000, 0, 0 }; - int width, height; int i; if ((buffer[6] & 0x20) != 0x20) /* missing marker_bit */ return 1; i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2]; - sequence->display_width = sequence->picture_width = width = i >> 12; - sequence->display_height = sequence->picture_height = height = i & 0xfff; - - if(width == 0 || height == 0) - return 1; - - decoder->width = sequence->width = width = (width + 15) & ~15; - decoder->height = sequence->height = height = (height + 15) & ~15; - decoder->vertical_position_extension = (height > 2800); - sequence->chroma_width = width >> 1; - sequence->chroma_height = height >> 1; + if (! (sequence->display_width = sequence->picture_width = i >> 12)) + return 1; + if (! (sequence->display_height = sequence->picture_height = i & 0xfff)) + return 1; + sequence->width = (sequence->picture_width + 15) & ~15; + sequence->height = (sequence->picture_height + 15) & ~15; + sequence->chroma_width = sequence->width >> 1; + sequence->chroma_height = sequence->height >> 1; - sequence->flags = SEQ_FLAG_PROGRESSIVE_SEQUENCE; + sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE | + SEQ_VIDEO_FORMAT_UNSPECIFIED); sequence->pixel_width = buffer[3] >> 4; /* aspect ratio */ - sequence->frame_period = 0; - if ((buffer[3] & 15) < 9) - sequence->frame_period = frame_period[buffer[3] & 15]; + sequence->frame_period = frame_period[buffer[3] & 15]; sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6); @@ -135,51 +171,40 @@ int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec) if (buffer[7] & 4) sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS; + mpeg2dec->copy_matrix = 3; if (buffer[7] & 2) { for (i = 0; i < 64; i++) - decoder->intra_quantizer_matrix[mpeg2_scan_norm[i]] = + mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] = (buffer[i+7] << 7) | (buffer[i+8] >> 1); buffer += 64; } else for (i = 0; i < 64; i++) - decoder->intra_quantizer_matrix[mpeg2_scan_norm[i]] = - default_intra_quantizer_matrix [i]; + mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] = + default_intra_quantizer_matrix[i]; if (buffer[7] & 1) for (i = 0; i < 64; i++) - decoder->non_intra_quantizer_matrix[mpeg2_scan_norm[i]] = + mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] = buffer[i+8]; else - for (i = 0; i < 64; i++) - decoder->non_intra_quantizer_matrix[i] = 16; + memset (mpeg2dec->new_quantizer_matrix[1], 16, 64); sequence->profile_level_id = 0x80; - sequence->colour_primaries = 1; - sequence->transfer_characteristics = 1; - sequence->matrix_coefficients = 1; - - decoder->mpeg1 = 1; - decoder->intra_dc_precision = 0; - decoder->frame_pred_frame_dct = 1; - decoder->q_scale_type = 0; - decoder->concealment_motion_vectors = 0; - decoder->scan = mpeg2_scan_norm; - decoder->picture_structure = FRAME_PICTURE; + sequence->colour_primaries = 0; + sequence->transfer_characteristics = 0; + sequence->matrix_coefficients = 0; mpeg2dec->ext_state = SEQ_EXT; mpeg2dec->state = STATE_SEQUENCE; mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0; - reset_info (&(mpeg2dec->info)); return 0; } static int sequence_ext (mpeg2dec_t * mpeg2dec) { uint8_t * buffer = mpeg2dec->chunk_start; - sequence_t * sequence = &(mpeg2dec->new_sequence); - decoder_t * decoder = &(mpeg2dec->decoder); - int width, height; + mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence); uint32_t flags; if (!(buffer[3] & 1)) @@ -187,31 +212,30 @@ static int sequence_ext (mpeg2dec_t * mpeg2dec) sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4); - width = sequence->display_width = sequence->picture_width += + sequence->display_width = sequence->picture_width += ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000; - height = sequence->display_height = sequence->picture_height += + sequence->display_height = sequence->picture_height += (buffer[2] << 7) & 0x3000; - decoder->vertical_position_extension = (height > 2800); + sequence->width = (sequence->picture_width + 15) & ~15; + sequence->height = (sequence->picture_height + 15) & ~15; flags = sequence->flags | SEQ_FLAG_MPEG2; if (!(buffer[1] & 8)) { flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE; - height = (height + 31) & ~31; + sequence->height = (sequence->height + 31) & ~31; } if (buffer[5] & 0x80) flags |= SEQ_FLAG_LOW_DELAY; sequence->flags = flags; - decoder->width = sequence->width = width = (width + 15) & ~15; - decoder->height = sequence->height = height = (height + 15) & ~15; + sequence->chroma_width = sequence->width; + sequence->chroma_height = sequence->height; switch (buffer[1] & 6) { case 0: /* invalid */ return 1; case 2: /* 4:2:0 */ - height >>= 1; + sequence->chroma_height >>= 1; case 4: /* 4:2:2 */ - width >>= 1; + sequence->chroma_width >>= 1; } - sequence->chroma_width = width; - sequence->chroma_height = height; sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000; @@ -220,8 +244,6 @@ static int sequence_ext (mpeg2dec_t * mpeg2dec) sequence->frame_period = sequence->frame_period * ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1); - decoder->mpeg1 = 0; - mpeg2dec->ext_state = SEQ_DISPLAY_EXT; return 0; @@ -230,7 +252,7 @@ static int sequence_ext (mpeg2dec_t * mpeg2dec) static int sequence_display_ext (mpeg2dec_t * mpeg2dec) { uint8_t * buffer = mpeg2dec->chunk_start; - sequence_t * sequence = &(mpeg2dec->new_sequence); + mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence); uint32_t flags; flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) | @@ -253,7 +275,7 @@ static int sequence_display_ext (mpeg2dec_t * mpeg2dec) return 0; } -static inline void finalize_sequence (sequence_t * sequence) +static inline void finalize_sequence (mpeg2_sequence_t * sequence) { int width; int height; @@ -308,35 +330,121 @@ static inline void finalize_sequence (sequence_t * sequence) sequence->pixel_height /= height; } +static void copy_matrix (mpeg2dec_t * mpeg2dec, int index) +{ + if (memcmp (mpeg2dec->quantizer_matrix[index], + mpeg2dec->new_quantizer_matrix[index], 64)) { + memcpy (mpeg2dec->quantizer_matrix[index], + mpeg2dec->new_quantizer_matrix[index], 64); + mpeg2dec->scaled[index] = -1; + } +} + +static void finalize_matrix (mpeg2dec_t * mpeg2dec) +{ + mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); + int i; + + for (i = 0; i < 2; i++) { + if (mpeg2dec->copy_matrix & (1 << i)) + copy_matrix (mpeg2dec, i); + if ((mpeg2dec->copy_matrix & (4 << i)) && + memcmp (mpeg2dec->quantizer_matrix[i], + mpeg2dec->new_quantizer_matrix[i+2], 64)) { + copy_matrix (mpeg2dec, i + 2); + decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2]; + } else if (mpeg2dec->copy_matrix & (5 << i)) + decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i]; + } +} + +static mpeg2_state_t invalid_end_action (mpeg2dec_t * mpeg2dec) +{ + mpeg2_reset_info (&(mpeg2dec->info)); + mpeg2dec->info.gop = NULL; + info_user_data (mpeg2dec); + mpeg2_header_state_init (mpeg2dec); + mpeg2dec->sequence = mpeg2dec->new_sequence; + mpeg2dec->action = mpeg2_seek_header; + mpeg2dec->state = STATE_SEQUENCE; + return STATE_SEQUENCE; +} + void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec) { - sequence_t * sequence = &(mpeg2dec->new_sequence); + mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence); + mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); finalize_sequence (sequence); - - /* - * according to 6.1.1.6, repeat sequence headers should be - * identical to the original. However some DVDs dont respect that - * and have different bitrates in the repeat sequence headers. So - * we'll ignore that in the comparison and still consider these as - * repeat sequence headers. - */ - mpeg2dec->sequence.byte_rate = sequence->byte_rate; - if (!memcmp (&(mpeg2dec->sequence), sequence, sizeof (sequence_t))) + finalize_matrix (mpeg2dec); + + decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2); + decoder->width = sequence->width; + decoder->height = sequence->height; + decoder->vertical_position_extension = (sequence->picture_height > 2800); + decoder->chroma_format = ((sequence->chroma_width == sequence->width) + + (sequence->chroma_height == sequence->height)); + + if (mpeg2dec->sequence.width != (unsigned)-1) { + unsigned int new_byte_rate; + + /* + * According to 6.1.1.6, repeat sequence headers should be + * identical to the original. However some DVDs dont respect + * that and have different bitrates in the repeat sequence + * headers. So we'll ignore that in the comparison and still + * consider these as repeat sequence headers. + * + * However, be careful not to alter the current sequence when + * returning STATE_INVALID_END. + */ + new_byte_rate = sequence->byte_rate; + sequence->byte_rate = mpeg2dec->sequence.byte_rate; + if (memcmp (&(mpeg2dec->sequence), sequence, + sizeof (mpeg2_sequence_t))) { + decoder->stride_frame = sequence->width; + sequence->byte_rate = new_byte_rate; + mpeg2_header_end (mpeg2dec); + mpeg2dec->action = invalid_end_action; + mpeg2dec->state = STATE_INVALID_END; + return; + } + sequence->byte_rate = new_byte_rate; mpeg2dec->state = STATE_SEQUENCE_REPEATED; + } else + decoder->stride_frame = sequence->width; mpeg2dec->sequence = *sequence; - + mpeg2_reset_info (&(mpeg2dec->info)); mpeg2dec->info.sequence = &(mpeg2dec->sequence); + mpeg2dec->info.gop = NULL; + info_user_data (mpeg2dec); } int mpeg2_header_gop (mpeg2dec_t * mpeg2dec) { + uint8_t * buffer = mpeg2dec->chunk_start; + mpeg2_gop_t * gop = &(mpeg2dec->new_gop); + + if (! (buffer[1] & 8)) + return 1; + gop->hours = (buffer[0] >> 2) & 31; + gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63; + gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63; + gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63; + gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6); mpeg2dec->state = STATE_GOP; - reset_info (&(mpeg2dec->info)); return 0; } -void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int coding_type) +void mpeg2_header_gop_finalize (mpeg2dec_t * mpeg2dec) +{ + mpeg2dec->gop = mpeg2dec->new_gop; + mpeg2_reset_info (&(mpeg2dec->info)); + mpeg2dec->info.gop = &(mpeg2dec->gop); + info_user_data (mpeg2dec); +} + +void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int b_type) { int i; @@ -345,9 +453,8 @@ void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int coding_type) 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)) + if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { + if (b_type || mpeg2dec->convert) mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; } @@ -355,32 +462,25 @@ void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int coding_type) } } -int mpeg2_header_picture_start (mpeg2dec_t * mpeg2dec) +mpeg2_state_t mpeg2_header_picture_start (mpeg2dec_t * mpeg2dec) { - decoder_t * decoder = &(mpeg2dec->decoder); - picture_t * picture; - - if (mpeg2dec->state != STATE_SLICE_1ST) { - mpeg2dec->state = STATE_PICTURE; - picture = mpeg2dec->pictures; - if ((decoder->coding_type != PIC_FLAG_CODING_TYPE_B) ^ - (mpeg2dec->picture >= mpeg2dec->pictures + 2)) - picture += 2; - } else { - mpeg2dec->state = STATE_PICTURE_2ND; - picture = mpeg2dec->picture + 1; /* second field picture */ - } - mpeg2dec->picture = picture; + mpeg2_picture_t * picture = &(mpeg2dec->new_picture); + + mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ? + STATE_PICTURE : STATE_PICTURE_2ND); picture->flags = 0; - if (mpeg2dec->num_pts) { - if (mpeg2dec->bytes_since_pts >= 4) { - mpeg2dec->num_pts = 0; - picture->pts = mpeg2dec->pts_current; - picture->flags = PIC_FLAG_PTS; - } else if (mpeg2dec->num_pts > 1) { - mpeg2dec->num_pts = 1; - picture->pts = mpeg2dec->pts_previous; - picture->flags = PIC_FLAG_PTS; + picture->tag = picture->tag2 = 0; + if (mpeg2dec->num_tags) { + if (mpeg2dec->bytes_since_tag >= 4) { + mpeg2dec->num_tags = 0; + picture->tag = mpeg2dec->tag_current; + picture->tag2 = mpeg2dec->tag2_current; + picture->flags = PIC_FLAG_TAGS; + } else if (mpeg2dec->num_tags > 1) { + mpeg2dec->num_tags = 1; + picture->tag = mpeg2dec->tag_previous; + picture->tag2 = mpeg2dec->tag2_previous; + picture->flags = PIC_FLAG_TAGS; } } picture->display_offset[0].x = picture->display_offset[1].x = @@ -393,80 +493,15 @@ int mpeg2_header_picture_start (mpeg2dec_t * mpeg2dec) int mpeg2_header_picture (mpeg2dec_t * mpeg2dec) { uint8_t * buffer = mpeg2dec->chunk_start; - picture_t * picture = mpeg2dec->picture; - decoder_t * decoder = &(mpeg2dec->decoder); + mpeg2_picture_t * picture = &(mpeg2dec->new_picture); + mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); int type; - int low_delay; type = (buffer [1] >> 3) & 7; - low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY; - - if (mpeg2dec->state == STATE_PICTURE) { - picture_t * other; - - decoder->second_field = 0; - other = mpeg2dec->pictures; - if (other == picture) - other += 2; - if (decoder->coding_type != PIC_FLAG_CODING_TYPE_B) { - mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; - mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; - } - mpeg2dec->fbuf[0] = NULL; - reset_info (&(mpeg2dec->info)); - mpeg2dec->info.current_picture = picture; - mpeg2dec->info.display_picture = picture; - if (type != PIC_FLAG_CODING_TYPE_B) { - if (!low_delay) { - if (mpeg2dec->first) { - mpeg2dec->info.display_picture = NULL; - mpeg2dec->first = 0; - } else { - mpeg2dec->info.display_picture = other; - if (other->nb_fields == 1) - mpeg2dec->info.display_picture_2nd = other + 1; - mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; - } - } - if (!low_delay + !mpeg2dec->convert_start) - mpeg2dec->info.discard_fbuf = - mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert_start]; - } - if (!mpeg2dec->custom_fbuf) { - while (mpeg2dec->alloc_index < 3) { - fbuf_t * fbuf; - - fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf); - fbuf->id = NULL; - if (mpeg2dec->convert_start) { - fbuf->buf[0] = - (uint8_t *) mpeg2_malloc (mpeg2dec->convert_size[0], - ALLOC_CONVERTED); - fbuf->buf[1] = fbuf->buf[0] + mpeg2dec->convert_size[1]; - fbuf->buf[2] = fbuf->buf[0] + mpeg2dec->convert_size[2]; - } else { - int size; - size = mpeg2dec->decoder.width * mpeg2dec->decoder.height; - fbuf->buf[0] = (uint8_t *) mpeg2_malloc (6 * size >> 2, - ALLOC_YUV); - fbuf->buf[1] = fbuf->buf[0] + size; - fbuf->buf[2] = fbuf->buf[1] + (size >> 2); - } - } - mpeg2_set_fbuf (mpeg2dec, type); - } - } else { - decoder->second_field = 1; - mpeg2dec->info.current_picture_2nd = picture; - mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0; - if (low_delay || type == PIC_FLAG_CODING_TYPE_B) - mpeg2dec->info.display_picture_2nd = picture; - } mpeg2dec->ext_state = PIC_CODING_EXT; picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6); - decoder->coding_type = type; picture->flags |= type; if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) { @@ -482,14 +517,22 @@ int mpeg2_header_picture (mpeg2dec_t * mpeg2dec) picture->nb_fields = 2; + mpeg2dec->q_scale_type = 0; + decoder->intra_dc_precision = 7; + decoder->frame_pred_frame_dct = 1; + decoder->concealment_motion_vectors = 0; + decoder->scan = mpeg2_scan_norm; + decoder->picture_structure = FRAME_PICTURE; + mpeg2dec->copy_matrix = 0; + return 0; } static int picture_coding_ext (mpeg2dec_t * mpeg2dec) { uint8_t * buffer = mpeg2dec->chunk_start; - picture_t * picture = mpeg2dec->picture; - decoder_t * decoder = &(mpeg2dec->decoder); + mpeg2_picture_t * picture = &(mpeg2dec->new_picture); + mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); uint32_t flags; /* pre subtract 1 for use later in compute_motion_vector */ @@ -499,7 +542,7 @@ static int picture_coding_ext (mpeg2dec_t * mpeg2dec) decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1; flags = picture->flags; - decoder->intra_dc_precision = (buffer[2] >> 2) & 3; + decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3); decoder->picture_structure = buffer[2] & 3; switch (decoder->picture_structure) { case TOP_FIELD: @@ -510,7 +553,7 @@ static int picture_coding_ext (mpeg2dec_t * mpeg2dec) case FRAME_PICTURE: if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)) { picture->nb_fields = (buffer[3] & 2) ? 3 : 2; - flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0; + flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0; flags |= (buffer[3] & 2) ? PIC_FLAG_REPEAT_FIRST_FIELD : 0; } else picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2; @@ -521,7 +564,7 @@ static int picture_coding_ext (mpeg2dec_t * mpeg2dec) decoder->top_field_first = buffer[3] >> 7; decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1; decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1; - decoder->q_scale_type = (buffer[3] >> 4) & 1; + mpeg2dec->q_scale_type = buffer[3] & 16; decoder->intra_vlc_format = (buffer[3] >> 3) & 1; decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm; flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0; @@ -538,7 +581,7 @@ static int picture_coding_ext (mpeg2dec_t * mpeg2dec) static int picture_display_ext (mpeg2dec_t * mpeg2dec) { uint8_t * buffer = mpeg2dec->chunk_start; - picture_t * picture = mpeg2dec->picture; + mpeg2_picture_t * picture = &(mpeg2dec->new_picture); int i, nb_pos; nb_pos = picture->nb_fields; @@ -564,6 +607,140 @@ static int picture_display_ext (mpeg2dec_t * mpeg2dec) return 0; } +void mpeg2_header_picture_finalize (mpeg2dec_t * mpeg2dec, uint32_t accels) +{ + mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); + int old_type_b = (decoder->coding_type == B_TYPE); + int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY; + + finalize_matrix (mpeg2dec); + decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE; + + if (mpeg2dec->state == STATE_PICTURE) { + mpeg2_picture_t * picture; + mpeg2_picture_t * other; + + decoder->second_field = 0; + + picture = other = mpeg2dec->pictures; + if (old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2)) + picture += 2; + else + other += 2; + mpeg2dec->picture = picture; + *picture = mpeg2dec->new_picture; + + if (!old_type_b) { + mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; + mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; + } + mpeg2dec->fbuf[0] = NULL; + mpeg2_reset_info (&(mpeg2dec->info)); + mpeg2dec->info.current_picture = picture; + mpeg2dec->info.display_picture = picture; + if (decoder->coding_type != B_TYPE) { + if (!low_delay) { + if (mpeg2dec->first) { + mpeg2dec->info.display_picture = NULL; + mpeg2dec->first = 0; + } else { + mpeg2dec->info.display_picture = other; + if (other->nb_fields == 1) + mpeg2dec->info.display_picture_2nd = other + 1; + mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; + } + } + if (!low_delay + !mpeg2dec->convert) + mpeg2dec->info.discard_fbuf = + mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert]; + } + if (mpeg2dec->convert) { + mpeg2_convert_init_t convert_init; + if (!mpeg2dec->convert_start) { + int y_size, uv_size; + + mpeg2dec->decoder.convert_id = + mpeg2_malloc (mpeg2dec->convert_id_size, + MPEG2_ALLOC_CONVERT_ID); + mpeg2dec->convert (MPEG2_CONVERT_START, + mpeg2dec->decoder.convert_id, + &(mpeg2dec->sequence), + mpeg2dec->convert_stride, accels, + mpeg2dec->convert_arg, &convert_init); + mpeg2dec->convert_start = convert_init.start; + mpeg2dec->decoder.convert = convert_init.copy; + + y_size = decoder->stride_frame * mpeg2dec->sequence.height; + uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format); + mpeg2dec->yuv_buf[0][0] = + (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV); + mpeg2dec->yuv_buf[0][1] = + (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); + mpeg2dec->yuv_buf[0][2] = + (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); + mpeg2dec->yuv_buf[1][0] = + (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV); + mpeg2dec->yuv_buf[1][1] = + (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); + mpeg2dec->yuv_buf[1][2] = + (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); + y_size = decoder->stride_frame * 32; + uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format); + mpeg2dec->yuv_buf[2][0] = + (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV); + mpeg2dec->yuv_buf[2][1] = + (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); + mpeg2dec->yuv_buf[2][2] = + (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV); + } + if (!mpeg2dec->custom_fbuf) { + while (mpeg2dec->alloc_index < 3) { + mpeg2_fbuf_t * fbuf; + + fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf; + fbuf->id = NULL; + fbuf->buf[0] = + (uint8_t *) mpeg2_malloc (convert_init.buf_size[0], + MPEG2_ALLOC_CONVERTED); + fbuf->buf[1] = + (uint8_t *) mpeg2_malloc (convert_init.buf_size[1], + MPEG2_ALLOC_CONVERTED); + fbuf->buf[2] = + (uint8_t *) mpeg2_malloc (convert_init.buf_size[2], + MPEG2_ALLOC_CONVERTED); + } + mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE)); + } + } else if (!mpeg2dec->custom_fbuf) { + while (mpeg2dec->alloc_index < 3) { + mpeg2_fbuf_t * fbuf; + int y_size, uv_size; + + fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf); + fbuf->id = NULL; + y_size = decoder->stride_frame * mpeg2dec->sequence.height; + uv_size = y_size >> (2 - decoder->chroma_format); + fbuf->buf[0] = (uint8_t *) mpeg2_malloc (y_size, + MPEG2_ALLOC_YUV); + fbuf->buf[1] = (uint8_t *) mpeg2_malloc (uv_size, + MPEG2_ALLOC_YUV); + fbuf->buf[2] = (uint8_t *) mpeg2_malloc (uv_size, + MPEG2_ALLOC_YUV); + } + mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE)); + } + } else { + decoder->second_field = 1; + mpeg2dec->picture++; /* second field picture */ + *(mpeg2dec->picture) = mpeg2dec->new_picture; + mpeg2dec->info.current_picture_2nd = mpeg2dec->picture; + if (low_delay || decoder->coding_type == B_TYPE) + mpeg2dec->info.display_picture_2nd = mpeg2dec->picture; + } + + info_user_data (mpeg2dec); +} + static int copyright_ext (mpeg2dec_t * mpeg2dec) { return 0; @@ -572,20 +749,16 @@ static int copyright_ext (mpeg2dec_t * mpeg2dec) static int quant_matrix_ext (mpeg2dec_t * mpeg2dec) { uint8_t * buffer = mpeg2dec->chunk_start; - decoder_t * decoder = &(mpeg2dec->decoder); - int i; - - if (buffer[0] & 8) { - for (i = 0; i < 64; i++) - decoder->intra_quantizer_matrix[mpeg2_scan_norm[i]] = - (buffer[i] << 5) | (buffer[i+1] >> 3); - buffer += 64; - } - - if (buffer[0] & 4) - for (i = 0; i < 64; i++) - decoder->non_intra_quantizer_matrix[mpeg2_scan_norm[i]] = - (buffer[i] << 6) | (buffer[i+1] >> 2); + int i, j; + + for (i = 0; i < 4; i++) + if (buffer[0] & (8 >> i)) { + for (j = 0; j < 64; j++) + mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] = + (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i)); + mpeg2dec->copy_matrix |= 1 << i; + buffer += 64; + } return 0; } @@ -609,41 +782,59 @@ int mpeg2_header_extension (mpeg2dec_t * mpeg2dec) int mpeg2_header_user_data (mpeg2dec_t * mpeg2dec) { - if (!mpeg2dec->info.user_data_len) - mpeg2dec->info.user_data = mpeg2dec->chunk_start; - else - mpeg2dec->info.user_data_len += 3; - mpeg2dec->info.user_data_len += (mpeg2dec->chunk_ptr - 4 - - mpeg2dec->chunk_start); + mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start; mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1; return 0; } -int mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec) +static void prescale (mpeg2dec_t * mpeg2dec, int index) { + static int non_linear_scale [] = { + 0, 1, 2, 3, 4, 5, 6, 7, + 8, 10, 12, 14, 16, 18, 20, 22, + 24, 28, 32, 36, 40, 44, 48, 52, + 56, 64, 72, 80, 88, 96, 104, 112 + }; + int i, j, k; + mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); + + if (mpeg2dec->scaled[index] != mpeg2dec->q_scale_type) { + mpeg2dec->scaled[index] = mpeg2dec->q_scale_type; + for (i = 0; i < 32; i++) { + k = mpeg2dec->q_scale_type ? non_linear_scale[i] : (i << 1); + for (j = 0; j < 64; j++) + decoder->quantizer_prescale[index][i][j] = + k * mpeg2dec->quantizer_matrix[index][j]; + } + } +} + +mpeg2_state_t mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec) +{ + mpeg2_decoder_t * decoder = &(mpeg2dec->decoder); + + mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0; mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 || mpeg2dec->state == STATE_PICTURE_2ND) ? STATE_SLICE : STATE_SLICE_1ST); + if (mpeg2dec->decoder.coding_type != D_TYPE) { + prescale (mpeg2dec, 0); + if (decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2]) + prescale (mpeg2dec, 2); + if (mpeg2dec->decoder.coding_type != I_TYPE) { + prescale (mpeg2dec, 1); + if (decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3]) + prescale (mpeg2dec, 3); + } + } + if (!(mpeg2dec->nb_decode_slices)) mpeg2dec->picture->flags |= PIC_FLAG_SKIP; else if (mpeg2dec->convert_start) { - int flags; - - switch (mpeg2dec->decoder.picture_structure) { - case TOP_FIELD: flags = CONVERT_TOP_FIELD; break; - case BOTTOM_FIELD: flags = CONVERT_BOTTOM_FIELD; break; - default: - flags = - ((mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) ? - CONVERT_FRAME : CONVERT_BOTH_FIELDS); - } - mpeg2dec->convert_start (mpeg2dec->convert_id, - mpeg2dec->fbuf[0]->buf, flags); - - mpeg2dec->decoder.convert = mpeg2dec->convert_copy; - mpeg2dec->decoder.fbuf_id = mpeg2dec->convert_id; + mpeg2dec->convert_start (decoder->convert_id, mpeg2dec->fbuf[0], + mpeg2dec->picture, mpeg2dec->info.gop); if (mpeg2dec->decoder.coding_type == B_TYPE) mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->yuv_buf[2], @@ -660,37 +851,45 @@ int mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec) } else { int b_type; - //mpeg2dec->decoder.convert = NULL; b_type = (mpeg2dec->decoder.coding_type == B_TYPE); mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf, mpeg2dec->fbuf[b_type + 1]->buf, mpeg2dec->fbuf[b_type]->buf); } mpeg2dec->action = NULL; - return 0; + return (mpeg2_state_t)-1; } -int mpeg2_header_end (mpeg2dec_t * mpeg2dec) +static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec) { - picture_t * picture; + mpeg2_reset_info (&(mpeg2dec->info)); + mpeg2dec->info.sequence = NULL; + mpeg2dec->info.gop = NULL; + mpeg2_header_state_init (mpeg2dec); + mpeg2dec->action = mpeg2_seek_header; + return mpeg2_seek_header (mpeg2dec); +} + +mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec) +{ + mpeg2_picture_t * picture; int b_type; + b_type = (mpeg2dec->decoder.coding_type == B_TYPE); picture = mpeg2dec->pictures; - if (mpeg2dec->picture < picture + 2) + if ((mpeg2dec->picture >= picture + 2) ^ b_type) picture = mpeg2dec->pictures + 2;