ARCH=MMX
#ARCH=PPC
+# Decoder choice - ?? old decoder will be removed soon
+DECODER=old
+#DECODER=new
+
#----------------- do not change anything below this line ----------------------
################################################################################
#??generic_decoder_obj = generic_decoder/generic_decoder.o
# remeber to add it to OBJ
+ifeq ($(DECODER),old)
video_decoder_obj = video_decoder_ref/video_decoder.o \
video_decoder_ref/display.o \
video_decoder_ref/getblk.o \
video_decoder_ref/motion.o \
video_decoder_ref/mpeg2dec.o \
video_decoder_ref/recon.o \
- video_decoder_ref/spatscal.o
-# video_decoder_ref/$(TRANSFORM).o
-
-#video_parser_obj = video_parser/video_parser.o \
-# video_parser/vpar_headers.o \
-# video_parser/vpar_blocks.o \
-# video_parser/vpar_motion.o \
-# video_parser/vpar_synchro.o \
-# video_parser/video_fifo.o
-
-#video_decoder_obj = video_decoder/video_decoder.o \
-# video_decoder/vdec_idct.o \
-# video_decoder/vdec_motion.o
+ video_decoder_ref/spatscal.o
+else
+video_parser_obj = video_parser/video_parser.o \
+ video_parser/vpar_headers.o \
+ video_parser/vpar_blocks.o \
+ video_parser/vpar_motion.o \
+ video_parser/vpar_synchro.o \
+ video_parser/video_fifo.o
+
+video_decoder_obj = video_decoder/video_decoder.o \
+ video_decoder/vdec_motion.o \
+ video_decoder/$(TRANSFORM).o
+endif
misc_obj = misc/mtime.o \
misc/rsc_files.o \
* shift" instructions that shift in copies of the sign bit. But some
* C compilers implement >> with an unsigned shift. For these machines you
* must define RIGHT_SHIFT_IS_UNSIGNED.
- * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
+ * RIGHT_SHIFT provides a proper signed right shift of an s32 quantity.
* It is only applied with constant shift counts. SHIFT_TEMPS must be
* included in the variables of any routine using RIGHT_SHIFT.
*/
#ifdef RIGHT_SHIFT_IS_UNSIGNED
-#define SHIFT_TEMPS INT32 shift_temp;
+#define SHIFT_TEMPS s32 shift_temp;
#define RIGHT_SHIFT(x,shft) \
((shift_temp = (x)) < 0 ? \
- (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
+ (shift_temp >> (shft)) | ((~((s32) 0)) << (32-(shft))) : \
(shift_temp >> (shft)))
#else
#define SHIFT_TEMPS
* they are represented to better-than-integral precision. These outputs
* require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
* with the recommended scaling. (To scale up 12-bit sample data further, an
- * intermediate INT32 array would be needed.)
+ * intermediate s32 array would be needed.)
*
* To avoid overflow of the 32-bit intermediate results in pass 2, we must
* have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis
* shows that the values given below are the most effective.
*/
+#define CONST_BITS 13 /* Jimmy chose this constant :) */
+
#ifdef EIGHT_BIT_SAMPLES
#define PASS1_BITS 2
#else
#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
#endif
-#define ONE ((INT32) 1)
+#define ONE ((s32) 1)
#define CONST_SCALE (ONE << CONST_BITS)
* the correct integer constant values and insert them by hand.
*/
-#define FIX(x) ((INT32) ((x) * CONST_SCALE + 0.5))
+#define FIX(x) ((s32) ((x) * CONST_SCALE + 0.5))
/* When adding two opposite-signed fixes, the 0.5 cancels */
-#define FIX2(x) ((INT32) ((x) * CONST_SCALE))
+#define FIX2(x) ((s32) ((x) * CONST_SCALE))
-/* Descale and correctly round an INT32 value that's scaled by N bits.
+/* Descale and correctly round an s32 value that's scaled by N bits.
* We assume RIGHT_SHIFT rounds towards minus infinity, so adding
* the fudge factor is correct for either sign of X.
*/
#define DESCALE(x,n) RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
-/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+/* Multiply an s32 variable by an s32 constant to yield an s32 result.
* For 8-bit samples with the recommended scaling, all the variable
* and constant values involved are no more than 16 bits wide, so a
* 16x16->32 bit multiply can be used instead of a full 32x32 multiply;
#define MULTIPLY(var,const) (((INT16) (var)) * ((INT16) (const)))
#endif
#ifdef SHORTxLCONST_32 /* known to work with Microsoft C 6.0 */
-#define MULTIPLY(var,const) (((INT16) (var)) * ((INT32) (const)))
+#define MULTIPLY(var,const) (((INT16) (var)) * ((s32) (const)))
#endif
#endif
void vdec_MotionFrame ( struct macroblock_s* );
/* Motion compensation for non skipped macroblocks */
-void vdec_FieldRecon ( struct macroblock_s* );
-void vdec_16x8Recon ( struct macroblock_s* );
-void vdec_FrameRecon ( struct macroblock_s* );
-void vdec_DMVRecon ( struct macroblock_s* );
+void vdec_FieldDMVRecon ( struct macroblock_s* );
+void vdec_FieldFieldRecon ( struct macroblock_s* );
+void vdec_Field16x8Recon ( struct macroblock_s* );
+void vdec_FrameFrameRecon ( struct macroblock_s* );
+void vdec_FrameFieldRecon ( struct macroblock_s* );
+void vdec_FrameDMVRecon ( struct macroblock_s* );
/* Motion compensation functions for the 3 chroma formats */
void vdec_Motion420();
/*??*/
// int *pi_status;
+ /* idct iformations */
+ elem_t p_pre_idct[64*64];
+
/* Input properties */
struct vpar_thread_s * p_vpar; /* video_parser thread */
#endif
} vdec_thread_t;
-/* Move this somewhere else ASAP !! */
-#define data_t short
-
/*****************************************************************************
* Function pointers
*****************************************************************************/
-typedef void (*f_addb_t)( vdec_thread_t*, elem_t*, data_t*, int );
+typedef void (*f_addb_t)( elem_t*, yuv_data_t*, int );
/*****************************************************************************
* Prototypes
/* Thread management functions */
vdec_thread_t * vdec_CreateThread ( struct vpar_thread_s *p_vpar /*, int *pi_status */ );
-void vdec_DestroyThread ( vdec_thread_t *p_vdec /*, int *pi_status */ );
-void vdec_AddBlock( vdec_thread_t*, elem_t*, data_t*, int );
-void vdec_CopyBlock( vdec_thread_t*, elem_t*, data_t*, int );
-void vdec_DummyBlock( vdec_thread_t*, elem_t*, data_t*, int );
+void vdec_DestroyThread ( vdec_thread_t *p_vdec /*, int *pi_status */ );
+void vdec_AddBlock( elem_t*, yuv_data_t*, int );
+void vdec_CopyBlock( elem_t*, yuv_data_t*, int );
+void vdec_DummyBlock( elem_t*, yuv_data_t*, int );
*****************************************************************************/
typedef struct macroblock_s
{
- picture_t * p_picture;
+ int i_mb_type; /* macroblock type */
int i_structure;
+ int i_current_structure;
+ boolean_t b_P_coding_type; /* Is it P_CODING_TYPE ? */
+ picture_t * p_picture;
int i_l_x, i_l_y; /* position of macroblock (lum) */
int i_c_x, i_c_y; /* position of macroblock (chroma) */
int i_chroma_nb_blocks; /* nb of bks for a chr comp */
- int i_l_stride; /* number of data_t to ignore
+ int i_l_stride; /* number of yuv_data_t to ignore
* when changing lines */
int i_c_stride; /* idem, for chroma */
int ppi_field_select[2][2];
int pppi_motion_vectors[2][2][2];
int pi_dm_vector[2];
-
+
/* AddBlock information */
f_addb_t pf_addb[12]; /* pointer to the Add function */
- data_t p_data[12]; /* pointer to the position
- * in the final picture */
+ yuv_data_t * p_data[12]; /* pointer to the position
+ * in the final picture */
int i_addb_l_stride, i_addb_c_stride;
} macroblock_t;
/*****************************************************************************
* Constants
*****************************************************************************/
-extern int * pi_default_intra_quant;
-extern int * pi_default_nonintra_quant;
+extern int pi_default_intra_quant[];
+extern int pi_default_nonintra_quant[];
extern u8 pi_scan[2][64];
/*****************************************************************************
/*******************************************************************************
* Preamble
- ******************************************************************************/
+ *******************************************************************************/
+#include "vlc.h"
+
+/*
#include <errno.h>
-#include <sys/uio.h> /* iovec */
+#include <sys/uio.h>
#include <string.h>
#include <X11/Xlib.h>
#include <X11/extensions/XShm.h>
#include <sys/soundcard.h>
-#include <stdlib.h> /* atoi(), malloc(), free() */
+#include <stdlib.h>
#include <stdio.h>
-#include <sys/ioctl.h> /* ioctl() */
-#include <net/if.h> /* ifreq */
+#include <sys/ioctl.h>
+#include <net/if.h>
#include <netinet/in.h>
#include "common.h"
#include "video.h"
#include "video_output.h"
#include "video_decoder.h"
+*/
/******************************************************************************
* Local prototypes
#ifdef NO_THREAD
input_Thread( p_input );
#else
- if( vlc_thread_create(&p_input->thread_id, "input", (vlc_thread_func)input_Thread,
+ if( vlc_thread_create(&p_input->thread_id, "input", (vlc_thread_func_t)input_Thread,
(void *) p_input) )
{
intf_ErrMsg("input error: can't spawn input thread (%s)\n",
EndThread( p_input );
intf_DbgMsg("input debug: thread %p destroyed\n", p_input);
- vlc_thread_exit( 0 );
+ vlc_thread_exit();
}
{
case MPEG1_VIDEO_ES:
case MPEG2_VIDEO_ES:
- vpar_DestroyThread( (vpar_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
+ vdec_DestroyThread( (vdec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
break;
case MPEG1_AUDIO_ES:
pcr_descriptor_t * p_pcr;
p_pcr = p_input->p_pcr;
- vlc_mutex_lock( &p_pcr->lock );
- if( p_pcr->delta_clock == 0 )
+
+ p_pes->i_pts =
+ ( ((mtime_t)(p_pes->p_pes_header[9] & 0x0E) << 29) |
+ (((mtime_t)U16_AT(p_pes->p_pes_header + 10) << 14) - (1 << 14)) |
+ ((mtime_t)U16_AT(p_pes->p_pes_header + 12) >> 1) ) * 300;
+ p_pes->i_pts /= 27;
+
+ if( p_pcr->i_synchro_state )
{
- p_pes->b_has_pts = 0;
+ switch( p_pcr->i_synchro_state )
+ {
+ case SYNCHRO_NOT_STARTED:
+ p_pes->b_has_pts = 0;
+ break;
+
+ case SYNCHRO_START:
+ p_pes->i_pts += p_pcr->delta_pcr;
+ p_pcr->delta_absolute = mdate() - p_pes->i_pts + 500000;
+ p_pes->i_pts += p_pcr->delta_absolute;
+ p_pcr->i_synchro_state = 0;
+ break;
+
+ case SYNCHRO_REINIT: /* We skip a PES */
+ p_pes->b_has_pts = 0;
+ p_pcr->i_synchro_state = SYNCHRO_START;
+ break;
+ }
}
else
{
- p_pes->i_pts = ( ((mtime_t)(p_pes->p_pes_header[9] & 0x0E) << 29) |
- (((mtime_t)U16_AT(p_pes->p_pes_header + 10) << 14) - (1 << 14)) |
- ((mtime_t)U16_AT(p_pes->p_pes_header + 12) >> 1) );
- p_pes->i_pts *= 300;
- p_pes->i_pts /= 27;
- p_pes->i_pts += p_pcr->delta_clock;
- if( p_pcr->c_pts == 0 )
- {
- p_pcr->delta_decode = mdate() - p_pes->i_pts + 500000;
- }
- p_pes->i_pts += p_pcr->delta_decode;
- p_pcr->c_pts += 1;
+ p_pes->i_pts += p_pcr->delta_pcr + p_pcr->delta_absolute;
}
- vlc_mutex_unlock( &p_pcr->lock );
}
break;
}
/*******************************************************************************
* Preamble
*******************************************************************************/
+
+#include "vlc.h"
+
+#if 0
#include <errno.h>
#include <sys/uio.h> /* iovec */
#include <stdlib.h> /* atoi(), malloc(), free() */
#include "video.h"
#include "video_output.h"
#include "video_decoder.h"
-
+#endif
/******************************************************************************
* input_AddPgrmElem: Start the extraction and the decoding of a program element
/*****************************************************************************
* Preamble
*****************************************************************************/
+
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include "decoder_fifo.h"
#include "video.h"
#include "video_output.h"
-#include "video_parser.h"
-#include "video_fifo.h"
+#include "vdec_idct.h"
#include "video_decoder.h"
+#include "vdec_motion.h"
-#include "vdec_idct.h"
+#include "vpar_blocks.h"
+#include "vpar_headers.h"
+#include "video_fifo.h"
+#include "vpar_synchro.h"
+#include "video_parser.h"
/*
* Local prototypes
void vdec_InitIDCT (vdec_thread_t * p_vdec)
{
int i;
- elem_t p_pre[][64]=vdec_thread_t->p_pre_idct;
- for (i=0; i<64; i++)
+
+ elem_t * p_pre = p_vdec->p_pre_idct;
+ memset( p_pre, 0, 64*64*sizeof(elem_t) );
+
+ for( i=0 ; i < 64 ; i++ )
{
- memset ((char *) p_pre[i], 0, 64*sizeof(elem_t));
- p_pre[i][i]= 1 << SPARSE_SCALE_FACTOR;
- vdec_IDCT (p_vdec, p_pre[i], 0);
+ p_pre[i*64+i] = 1 << SPARSE_SCALE_FACTOR;
+ vdec_IDCT( p_vdec, &p_pre[i*64], 0) ;
}
}
if ( i_sparse_pos == 0 )
{
- dp=(int *)p_block;
- val= *p_block >> 6;
- /* Compute int to assign. This speeds things up a bit */
+ dp=(int *)p_block;
+ val= *p_block >> 6;
+ /* Compute int to assign. This speeds things up a bit */
v = ((val & 0xffff) | (val << 16));
dp[0] = v; dp[1] = v; dp[2] = v; dp[3] = v;
dp[4] = v; dp[5] = v; dp[6] = v; dp[7] = v;
return;
}
/* Some other coefficient. */
- p_dest=(short int *)p_block;
- p_source=(short int *)p_vdec->p_pre_idct[i_sparse_pos];
- coef=p_dest[i_sparse_pos];
- for (rr=0; rr<4; rr++)
+ p_dest = (s16*)p_block;
+ p_source = (s16*)&p_vdec->p_pre_idct[i_sparse_pos];
+ coeff = (int)p_dest[i_sparse_pos];
+ for( rr=0 ; rr < 4 ; rr++ )
{
p_dest[0] = (p_source[0] * coeff) >> SPARSE_SCALE_FACTOR;
p_dest[1] = (p_source[1] * coeff) >> SPARSE_SCALE_FACTOR;
*****************************************************************************/
void vdec_IDCT( vdec_thread_t * p_vdec, elem_t * p_block, int i_idontcare )
{
- INT32 tmp0, tmp1, tmp2, tmp3;
- INT32 tmp10, tmp11, tmp12, tmp13;
- INT32 z1, z2, z3, z4, z5;
- INT32 d0, d1, d2, d3, d4, d5, d6, d7;
+ s32 tmp0, tmp1, tmp2, tmp3;
+ s32 tmp10, tmp11, tmp12, tmp13;
+ s32 z1, z2, z3, z4, z5;
+ s32 d0, d1, d2, d3, d4, d5, d6, d7;
elem_t * dataptr;
int rowctr;
+
SHIFT_TEMPS
- /* Pass 1: process rows. */
- /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
- /* furthermore, we scale the results by 2**PASS1_BITS. */
+ /* Pass 1: process rows. */
+ /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
+ /* furthermore, we scale the results by 2**PASS1_BITS. */
dataptr = p_block;
for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
{
- /* Due to quantization, we will usually find that many of the input
- * coefficients are zero, especially the AC terms. We can exploit this
- * by short-circuiting the IDCT calculation for any row in which all
- * the AC terms are zero. In that case each output is equal to the
- * DC coefficient (with scale factor as needed).
- * With typical images and quantization tables, half or more of the
- * row DCT calculations can be simplified this way.
- */
+ /* Due to quantization, we will usually find that many of the input
+ * coefficients are zero, especially the AC terms. We can exploit this
+ * by short-circuiting the IDCT calculation for any row in which all
+ * the AC terms are zero. In that case each output is equal to the
+ * DC coefficient (with scale factor as needed).
+ * With typical images and quantization tables, half or more of the
+ * row DCT calculations can be simplified this way.
+ */
register int * idataptr = (int*)dataptr;
d0 = dataptr[0];
/* Note that we must descale the results by a factor of 8 == 2**3, */
/* and also undo the PASS1_BITS scaling. */
- dataptr = data;
+ dataptr = p_block;
for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--)
{
/* Columns of zeroes can be exploited in the same way as we did with rows.
CONST_BITS+PASS1_BITS+3);
dataptr++; /* advance pointer to next column */
+ }
}
* Local prototypes
*/
+typedef struct motion_arg_s
+{
+ picture_t * p_source;
+ boolean_t b_source_field;
+ boolean_t b_dest_field;
+ int i_height;
+ int i_x_step;
+ int i_mv_x, i_mv_y;
+ boolean_t b_average;
+} motion_arg_t;
+
+/*
typedef void (*f_motion_c_t)( coeff_t *, pel_lookup_table_t *,
int, coeff_t *, int, int,
int, int, int, int, int );
+*/
+
+/*****************************************************************************
+ * vdec_MotionComponent : last stage of motion compensation
+ *****************************************************************************/
+static __inline__ vdec_MotionComponent()
+{
+
+}
/*****************************************************************************
* vdec_DummyRecon : motion compensation for an intra macroblock
*****************************************************************************/
void vdec_DummyRecon( macroblock_t * p_mb )
{
+ /* Nothing to do :) */
}
/*****************************************************************************
- * vdec_ForwardRecon : motion compensation for a forward predicted macroblock
+ * vdec_FieldFieldRecon : motion compensation for field motion type (field)
*****************************************************************************/
-void vdec_ForwardRecon( macroblock_t * p_mb )
+void vdec_FieldFieldRecon( macroblock_t * p_mb )
{
+#if 0
+ motion_arg_t motion_arg;
+ motion_arg
+
+ if( p_mb->i_mb_type & MB_MOTION_FORWARD )
+ {
+ int i_current_field;
+ picture_t * p_pred_frame;
+
+ i_current_field = ( p_mb->i_structure == BOTTOM_FIELD );
+ if( p_mb->b_P_coding_type && (p_mb->i_current_structure == FRAME_STRUCTURE)
+ && (i_current_field != p_mb->ppi_field_select[0][0]) )
+ {
+ p_pred_frame = p_mb->p_forward;
+ }
+ else
+ {
+ p_pred_frame = p_mb->p_backward;
+ }
+ p_mb->pf_chroma_motion( p_mb, p_pred_frame, 0 /* average */ );
+ }
+#endif
}
/*****************************************************************************
- * vdec_BackwardRecon : motion compensation for a backward predicted macroblock
+ * vdec_Field16x8Recon : motion compensation for 16x8 motion type (field)
*****************************************************************************/
-void vdec_BackwardRecon( macroblock_t * p_mb )
+void vdec_Field16x8Recon( macroblock_t * p_mb )
{
}
/*****************************************************************************
- * vdec_BidirectionalRecon : motion compensation for a bidirectionally
- * predicted macroblock
+ * vdec_FieldDMVRecon : motion compensation for dmv motion type (field)
*****************************************************************************/
-void vdec_BidirectionalRecon( macroblock_t * p_mb )
+void vdec_FieldDMVRecon( macroblock_t * p_mb )
+{
+ /* This is necessarily a MOTION_FORWARD only macroblock */
+
+}
+
+/*****************************************************************************
+ * vdec_FrameFrameRecon : motion compensation for frame motion type (frame)
+ *****************************************************************************/
+void vdec_FrameFrameRecon( macroblock_t * p_mb )
+{
+
+}
+
+/*****************************************************************************
+ * vdec_FrameFieldRecon : motion compensation for field motion type (frame)
+ *****************************************************************************/
+void vdec_FrameFieldRecon( macroblock_t * p_mb )
{
}
+/*****************************************************************************
+ * vdec_FrameDMVRecon : motion compensation for dmv motion type (frame)
+ *****************************************************************************/
+void vdec_FrameDMVRecon( macroblock_t * p_mb )
+{
+ /* This is necessarily a MOTION_FORWARD only macroblock */
+
+}
+
+/*****************************************************************************
+ * vdec_MotionField : motion compensation for skipped macroblocks (field)
+ *****************************************************************************/
+void vdec_MotionField( macroblock_t * p_mb )
+{
+
+}
+
+/*****************************************************************************
+ * vdec_MotionFrame : motion compensation for skipped macroblocks (frame)
+ *****************************************************************************/
+void vdec_MotionFrame( macroblock_t * p_mb )
+{
+
+}
+
+/*****************************************************************************
+ * vdec_Motion420 : motion compensation for a 4:2:0 macroblock
+ *****************************************************************************/
+void vdec_Motion420( macroblock_t * p_mb )
+{
+}
+
+/*****************************************************************************
+ * vdec_Motion422 : motion compensation for a 4:2:2 macroblock
+ *****************************************************************************/
+void vdec_Motion422( macroblock_t * p_mb )
+{
+}
+
+/*****************************************************************************
+ * vdec_Motion444 : motion compensation for a 4:4:4 macroblock
+ *****************************************************************************/
+void vdec_Motion444( macroblock_t * p_mb )
+{
+}
+
+#if 0
+
/*****************************************************************************
* vdec_MotionMacroblock420 : motion compensation for a 4:2:0 macroblock
*****************************************************************************/
void vdec_MotionMacroblock420( macroblock_t * p_mb )
{
/* Luminance */
+ /*
MotionBlock( p_undec_p->p_forward->p_u, p_undec_p->p_forward->p_lookup_lum,
p_undec_p->p_picture->i_width, p_u, i_mb_x, i_mb_y,
p_undec_p->p_picture->i_width,
p_undec_p->ppp_motion_vectors[0][0][0],
p_undec_p->ppp_motion_vectors[0][0][1] );
-
+ */
}
/*****************************************************************************
i_src_loc += i_stride_line;
}
}
+
+#endif
/*******************************************************************************
* Preamble
*******************************************************************************/
-#include "vlc.h"
+//#include "vlc.h"
-/*#include <errno.h>
-#include <pthread.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include "vlc_thread.h"
#include "intf_msg.h"
-#include "debug.h"
+#include "debug.h" /* ?? temporaire, requis par netlist.h */
#include "input.h"
#include "input_netlist.h"
#include "decoder_fifo.h"
#include "video.h"
#include "video_output.h"
-#include "video_decoder.h"*/
-
#include "vdec_idct.h"
#include "video_decoder.h"
/* Spawn the video decoder thread */
if ( vlc_thread_create(&p_vdec->thread_id, "video decoder",
- (vlc_thread_func)RunThread, (void *)p_vdec) )
+ (vlc_thread_func_t)RunThread, (void *)p_vdec) )
{
intf_ErrMsg("vdec error: can't spawn video decoder thread\n");
free( p_vdec );
* Adding prediction and coefficient data (ISO/IEC 13818-2 section 7.6.8)
*/
(p_mb->pf_addb[i_b])( p_mb->ppi_blocks[i_b],
- p_mb->p_data[i_b], p_mb->i_l_stride );
+ p_mb->p_data[i_b], p_mb->i_l_stride );
}
/* chrominance */
/*
* Adding prediction and coefficient data (ISO/IEC 13818-2 section 7.6.8)
*/
- (p_mb->pf_addb[i_b])( p_mb->ppi_blocks[i_b],
- p_mb->p_data[i_b], p_mb->i_c_stride );
+ (p_mb->pf_addb[i_b])( (elem_t*)p_mb->ppi_blocks[i_b],
+ p_mb->p_data[i_b], p_mb->i_c_stride );
}
/*
/*******************************************************************************
* vdec_AddBlock : add a block
*******************************************************************************/
-void vdec_AddBlock( vdec_thread_t * p_vdec, elem_t * p_block, data_t * p_data,
- int i_incr )
+void vdec_AddBlock( elem_t * p_block, yuv_data_t * p_data, int i_incr )
{
int i_x, i_y;
/*******************************************************************************
* vdec_CopyBlock : copy a block
*******************************************************************************/
-void vdec_CopyBlock( vdec_thread_t * p_vdec, elem_t * p_block, data_t * p_data,
- int i_incr )
+void vdec_CopyBlock( elem_t * p_block, yuv_data_t * p_data, int i_incr )
{
int i_x, i_y;
for( i_y = 0; i_y < 8; i_y++ )
{
#ifndef VDEC_DFT
- /* elem_t and data_t are the same */
- memcopy( p_data, p_block, 8*sizeof(data_t) );
+ /* elem_t and yuv_data_t are the same */
+ memcpy( p_data, p_block, 8*sizeof(yuv_data_t) );
p_data += i_incr+8;
p_block += 8;
#else
/*******************************************************************************
* vdec_DummyBlock : dummy function that does nothing
*******************************************************************************/
-void vdec_DummyBlock( vdec_thread_t * p_vdec, elem_t * p_block, data_t * p_data,
- int i_incr )
+void vdec_DummyBlock( elem_t * p_block, yuv_data_t * p_data, int i_incr )
{
}
/* Unlink picture buffer */
vlc_mutex_lock( &p_mb->p_picture->lock_deccount );
p_mb->p_picture->i_deccount--;
+
+ /* Test if it was the last block of the picture */
if( p_mb->p_picture->i_deccount == 0 )
{
/* Mark the picture to be displayed */
memcpy( p_vpar->ppl_dct_coef[8], pl_DCT_tab6, sizeof( pl_DCT_tab6 ) );
memcpy( p_vpar->ppl_dct_coef[9], pl_DCT_tab0a, sizeof( pl_DCT_tab0a ) );
memcpy( p_vpar->ppl_dct_coef[10], pl_DCT_tab1a, sizeof( pl_DCT_tab1a ) );
-
-
}
/*
/* Calculate block coordinates. */
p_mb->p_data[i_b] = p_data1
- + pi_y[p_vpar->mb.b_dct_type][i_b]
- * p_vpar->sequence.i_chroma_width;
+ + pi_y[p_vpar->mb.b_dct_type][i_b]
+ * p_vpar->sequence.i_chroma_width;
}
else
{
p_mb->p_picture = p_vpar->picture.p_picture;
p_mb->i_structure = p_vpar->picture.i_structure;
+ p_mb->i_current_structure = p_vpar->picture.i_current_structure;
p_mb->i_l_x = p_vpar->mb.i_l_x;
p_mb->i_l_y = p_vpar->mb.i_l_y;
p_mb->i_c_x = p_vpar->mb.i_c_x;
p_mb->i_c_y = p_vpar->mb.i_c_y;
p_mb->i_chroma_nb_blocks = p_vpar->sequence.i_chroma_nb_blocks;
p_mb->pf_chroma_motion = pf_chroma_motion[p_vpar->sequence.i_chroma_format];
+ p_mb->b_P_coding_type = ( p_vpar->picture.i_coding_type == P_CODING_TYPE );
p_mb->p_forward = p_vpar->sequence.p_forward;
p_mb->p_backward = p_vpar->sequence.p_backward;
macroblock_t * p_mb )
{
static f_motion_t pf_motion[2][4] =
- { {NULL, vdec_FieldRecon, vdec_16x8Recon, vdec_DMVRecon},
- {NULL, vdec_FieldRecon, vdec_FrameRecon, vdec_DMVRecon} };
+ { {NULL, vdec_FieldFieldRecon, vdec_Field16x8Recon, vdec_FieldDMVRecon},
+ {NULL, vdec_FrameFieldRecon, vdec_FrameFrameRecon, vdec_FrameDMVRecon} };
static int ppi_mv_count[2][4] = { {0, 1, 2, 1}, {0, 2, 1, 1} };
static int ppi_mv_format[2][4] = { {0, 1, 1, 1}, {0, 1, 2, 1} };
/* Get macroblock_type. */
p_vpar->mb.i_mb_type = (p_vpar->picture.pf_macroblock_type)( p_vpar );
-
+ p_mb->i_mb_type = p_vpar->mb.i_mb_type;
+
/* SCALABILITY : warning, we don't know if spatial_temporal_weight_code
* has to be dropped, take care if you use scalable streams. */
/* DumpBits( &p_vpar->bit_stream, 2 ); */
- if( (p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
- !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD|MB_INTRA)) )
+ if( p_mb->b_P_coding_type && !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD|MB_INTRA)) )
{
/* Special No-MC macroblock in P pictures (7.6.3.5). */
memset( p_vpar->slice.pppi_pmv, 0, 8*sizeof(int) );
default:
i_level = ( * ( p_vpar->ppl_dct_coef[i_select]
+ ( i_offset * sizeof(dct_lookup_t) ) ) ).i_level;
- b_sign = Getbits( &p_vpar->bit_stream, 1 );
+ b_sign = GetBits( &p_vpar->bit_stream, 1 );
p_mb->ppi_blocks[i_b][i_dummy] = b_sign ? -i_level : i_level;
i_coef = i_dummy;
i_dummy += i_run;
default:
i_level = ( * ( p_vpar->ppl_dct_coef[i_select]
+ ( i_offset * sizeof(dct_lookup_t) ) ) ).i_level;
- b_sign = Getbits( &p_vpar->bit_stream, 1 );
+ b_sign = GetBits( &p_vpar->bit_stream, 1 );
p_mb->ppi_blocks[i_b][i_dummy] = b_sign ? -i_level : i_level;
i_coef = i_dummy;
i_dummy += i_run;
*****************************************************************************/
void vpar_MPEG1MotionVector( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_s )
{
- p_vpar_MotionVector( p_vpar, p_mb, 0, i_s, p_vpar->picture.pb_full_pel_vector[i_s] );
+ vpar_MotionVector( p_vpar, p_mb, 0, i_s, p_vpar->picture.pb_full_pel_vector[i_s] );
}
/*****************************************************************************
{
}
+
+/*****************************************************************************
+ * vpar_SynchroEnd : Called when the image is totally decoded
+ *****************************************************************************/
+void vpar_SynchroEnd( vpar_thread_t * p_vpar )
+{
+
+}
+
+
+
projects / vlc / commitdiff