Commit f73dedb8 authored by Jean-Marc Dressler's avatar Jean-Marc Dressler

Pour la plus grande joie de tous, le client compile correctement. Attention

il compile non seulement avec l'ancien video decoder mais aussi avec le
nouveau. Pour passer de l'un a l'autre il faut changer le flag DECODER
du Makefile ET utiliser l'utilitaire new2old.sh gracieusement mis a votre
disposition par ptyx dans le module utils du CVS. Ce programme switche
quelques fichiers et permet dons de passer de l'ancien client au nouveau
et vis verca. Mais ATTENTION : IL NE FAUT PAS COMMITER LE CLIENT LORSQU'IL
EST EN CONFIGURATION NEW, avant de commiter il faut tout remettre en
configuration old.
parent 61ce43f4
......@@ -25,6 +25,10 @@ VIDEO=FB
ARCH=MMX
#ARCH=PPC
# Decoder choice - ?? old decoder will be removed soon
DECODER=old
#DECODER=new
#----------------- do not change anything below this line ----------------------
################################################################################
......@@ -174,6 +178,7 @@ audio_decoder_obj = audio_decoder/audio_decoder.o \
#??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 \
......@@ -184,19 +189,19 @@ video_decoder_obj = video_decoder_ref/video_decoder.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 \
......
......@@ -34,16 +34,16 @@ struct vdec_thread_s;
* 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
......@@ -79,20 +79,22 @@ struct vdec_thread_s;
* 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)
......@@ -102,19 +104,19 @@ struct vdec_thread_s;
* 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;
......@@ -130,7 +132,7 @@ struct vdec_thread_s;
#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
......
......@@ -32,10 +32,12 @@ void vdec_MotionField ( struct macroblock_s* );
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();
......
......@@ -33,6 +33,9 @@ typedef struct vdec_thread_s
/*??*/
// int *pi_status;
/* idct iformations */
elem_t p_pre_idct[64*64];
/* Input properties */
struct vpar_thread_s * p_vpar; /* video_parser thread */
......@@ -53,13 +56,10 @@ typedef struct vdec_thread_s
#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
......@@ -68,7 +68,7 @@ struct vpar_thread_s;
/* 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 );
......@@ -20,12 +20,15 @@
*****************************************************************************/
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 */
......@@ -42,11 +45,11 @@ typedef struct macroblock_s
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;
......@@ -122,8 +125,8 @@ typedef struct dct_lookup_s
/*****************************************************************************
* 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];
/*****************************************************************************
......
......@@ -8,19 +8,22 @@
/*******************************************************************************
* 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"
......@@ -44,6 +47,7 @@
#include "video.h"
#include "video_output.h"
#include "video_decoder.h"
*/
/******************************************************************************
* Local prototypes
......@@ -192,7 +196,7 @@ input_thread_t *input_CreateThread( input_cfg_t *p_cfg )
#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",
......@@ -304,7 +308,7 @@ static void input_Thread( input_thread_t *p_input )
EndThread( p_input );
intf_DbgMsg("input debug: thread %p destroyed\n", p_input);
vlc_thread_exit( 0 );
vlc_thread_exit();
}
......@@ -337,7 +341,7 @@ static void EndThread( input_thread_t * p_input )
{
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:
......@@ -915,27 +919,38 @@ static __inline__ void input_DemuxPES( input_thread_t *p_input,
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;
}
......
......@@ -9,6 +9,10 @@
/*******************************************************************************
* Preamble
*******************************************************************************/
#include "vlc.h"
#if 0
#include <errno.h>
#include <sys/uio.h> /* iovec */
#include <stdlib.h> /* atoi(), malloc(), free() */
......@@ -40,7 +44,7 @@
#include "video.h"
#include "video_output.h"
#include "video_decoder.h"
#endif
/******************************************************************************
* input_AddPgrmElem: Start the extraction and the decoding of a program element
......
......@@ -6,6 +6,7 @@
/*****************************************************************************
* Preamble
*****************************************************************************/
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
......@@ -28,12 +29,16 @@
#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
......@@ -58,12 +63,14 @@ void vdec_DummyIDCT( vdec_thread_t * p_vdec, elem_t * p_block,
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) ;
}
}
......@@ -81,9 +88,9 @@ void vdec_SparseIDCT (vdec_thread_t * p_vdec, elem_t * p_block,
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;
......@@ -96,10 +103,10 @@ void vdec_SparseIDCT (vdec_thread_t * p_vdec, elem_t * p_block,
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;
......@@ -129,30 +136,31 @@ void vdec_SparseIDCT (vdec_thread_t * p_vdec, elem_t * p_block,
*****************************************************************************/
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];
......@@ -732,7 +740,7 @@ void vdec_IDCT( vdec_thread_t * p_vdec, elem_t * p_block, int i_idontcare )
/* 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.
......@@ -1301,4 +1309,5 @@ void vdec_IDCT( vdec_thread_t * p_vdec, elem_t * p_block, int i_idontcare )
CONST_BITS+PASS1_BITS+3);
dataptr++; /* advance pointer to next column */
}
}
......@@ -43,54 +43,163 @@
* 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] );
*/
}
/*****************************************************************************
......@@ -153,3 +262,5 @@ void ComponentNN( coeff_t * p_src, pel_lookup_table_t * p_lookup,
i_src_loc += i_stride_line;
}
}
#endif
......@@ -8,10 +8,8 @@
/*******************************************************************************
* Preamble
*******************************************************************************/
#include "vlc.h"
//#include "vlc.h"
/*#include <errno.h>
#include <pthread.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
......@@ -27,15 +25,13 @@
#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"
......@@ -91,7 +87,7 @@ vdec_thread_t * vdec_CreateThread( vpar_thread_t *p_vpar /*, int *pi_status */ )
/* 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 );
......@@ -276,7 +272,7 @@ static void DecodeMacroblock( vdec_thread_t *p_vdec, macroblock_t * p_mb )
* 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 */
......@@ -291,8 +287,8 @@ static void DecodeMacroblock( vdec_thread_t *p_vdec, macroblock_t * p_mb )
/*
* 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 );
}
/*
......@@ -305,8 +301,7 @@ static void DecodeMacroblock( vdec_thread_t *p_vdec, macroblock_t * p_mb )
/*******************************************************************************
* 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;
......@@ -328,16 +323,15 @@ void vdec_AddBlock( vdec_thread_t * p_vdec, elem_t * p_block, data_t * p_data,
/*******************************************************************************
* 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
......@@ -355,7 +349,6 @@ void vdec_CopyBlock( vdec_thread_t * p_vdec, elem_t * p_block, data_t * p_data,