modules » codec » xvmc

slice.c File Reference

Include dependency graph for slice.c:


Defines

#define bit_buf   (decoder->bitstream_buf)
#define bits   (decoder->bitstream_bits)
#define bit_ptr   (decoder->bitstream_ptr)
#define bit_buf   (decoder->bitstream_buf)
#define bits   (decoder->bitstream_bits)
#define bit_ptr   (decoder->bitstream_ptr)
#define MOTION_420(table, ref, motion_x, motion_y, size, y)
#define MOTION_FIELD_420(table, ref, motion_x, motion_y, dest_field, op, src_field)
#define MOTION_DMV_420(table, ref, motion_x, motion_y)
#define MOTION_ZERO_420(table, ref)
#define MOTION_422(table, ref, motion_x, motion_y, size, y)
#define MOTION_FIELD_422(table, ref, motion_x, motion_y, dest_field, op, src_field)
#define MOTION_DMV_422(table, ref, motion_x, motion_y)
#define MOTION_ZERO_422(table, ref)
#define MOTION_444(table, ref, motion_x, motion_y, size, y)
#define MOTION_FIELD_444(table, ref, motion_x, motion_y, dest_field, op, src_field)
#define MOTION_DMV_444(table, ref, motion_x, motion_y)
#define MOTION_ZERO_444(table, ref)
#define bit_buf   (decoder->bitstream_buf)
#define bits   (decoder->bitstream_bits)
#define bit_ptr   (decoder->bitstream_ptr)
#define MOTION_FUNCTIONS(FORMAT, MOTION, MOTION_FIELD, MOTION_DMV, MOTION_ZERO)
#define MOTION_CALL(routine, direction)
#define NEXT_MACROBLOCK

Functions

static __attribute__ ((__always_inline__))
static void motion_mp1 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_frame_420 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_field_420 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_dmv_420 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_reuse_420 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_zero_420 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_field_420 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_16x8_420 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_dmv_420 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_frame_422 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_field_422 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_dmv_422 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_reuse_422 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_zero_422 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_field_422 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_16x8_422 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_dmv_422 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_frame_444 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_field_444 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_dmv_444 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_reuse_444 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_zero_444 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_field_444 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_16x8_444 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fi_dmv_444 (mpeg2_decoder_t *const decoder, motion_t *const motion, mpeg2_mc_fct *const *const table)
static void motion_fr_conceal (mpeg2_decoder_t *const decoder)
static void motion_fi_conceal (mpeg2_decoder_t *const decoder)
void mpeg2_init_fbuf (mpeg2_decoder_t *decoder, uint8_t *current_fbuf[3], uint8_t *forward_fbuf[3], uint8_t *backward_fbuf[3])

Variables

mpeg2_mc_t mpeg2_mc
void(*) mpeg2_cpu_state_save (cpu_state_t *state)
void(*) mpeg2_cpu_state_restore (cpu_state_t *state)

Define Documentation

#define bit_buf   (decoder->bitstream_buf)

#define bit_buf   (decoder->bitstream_buf)

#define bit_buf   (decoder->bitstream_buf)

#define bit_ptr   (decoder->bitstream_ptr)

#define bit_ptr   (decoder->bitstream_ptr)

#define bit_ptr   (decoder->bitstream_ptr)

#define bits   (decoder->bitstream_bits)

#define bits   (decoder->bitstream_bits)

#define bits   (decoder->bitstream_bits)

#define MOTION_420 ( table,
ref,
motion_x,
motion_y,
size,
y   ) 

Value:

pos_x = 2 * decoder->offset + motion_x;                   \
    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                 \
    if (unlikely (pos_x > decoder->limit_x)) {                    \
    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
    motion_x = pos_x - 2 * decoder->offset;                   \
    }                                         \
    if (unlikely (pos_y > decoder->limit_y_ ## size)) {               \
    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;         \
    motion_y = pos_y - 2 * decoder->v_offset - 2 * y;             \
    }                                         \
    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                   \
    table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
            ref[0] + (pos_x >> 1) + (pos_y >> 1) * decoder->stride,   \
            decoder->stride, size);                   \
    motion_x /= 2;  motion_y /= 2;                        \
    xy_half = ((motion_y & 1) << 1) | (motion_x & 1);                 \
    offset = (((decoder->offset + motion_x) >> 1) +               \
          ((((decoder->v_offset + motion_y) >> 1) + y/2) *            \
           decoder->uv_stride));                          \
    table[4+xy_half] (decoder->dest[1] + y/2 * decoder->uv_stride +       \
              (decoder->offset >> 1), ref[1] + offset,            \
              decoder->uv_stride, size/2);                \
    table[4+xy_half] (decoder->dest[2] + y/2 * decoder->uv_stride +       \
              (decoder->offset >> 1), ref[2] + offset,            \
              decoder->uv_stride, size/2)

#define MOTION_422 ( table,
ref,
motion_x,
motion_y,
size,
y   ) 

Value:

pos_x = 2 * decoder->offset + motion_x;                   \
    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                 \
    if (unlikely (pos_x > decoder->limit_x)) {                    \
    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
    motion_x = pos_x - 2 * decoder->offset;                   \
    }                                         \
    if (unlikely (pos_y > decoder->limit_y_ ## size)) {               \
    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;         \
    motion_y = pos_y - 2 * decoder->v_offset - 2 * y;             \
    }                                         \
    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                   \
    offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride;           \
    table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
            ref[0] + offset, decoder->stride, size);              \
    offset = (offset + (motion_x & (motion_x < 0))) >> 1;             \
    motion_x /= 2;                                \
    xy_half = ((pos_y & 1) << 1) | (motion_x & 1);                \
    table[4+xy_half] (decoder->dest[1] + y * decoder->uv_stride +         \
              (decoder->offset >> 1), ref[1] + offset,            \
              decoder->uv_stride, size);                  \
    table[4+xy_half] (decoder->dest[2] + y * decoder->uv_stride +         \
              (decoder->offset >> 1), ref[2] + offset,            \
              decoder->uv_stride, size)

#define MOTION_444 ( table,
ref,
motion_x,
motion_y,
size,
y   ) 

Value:

pos_x = 2 * decoder->offset + motion_x;                   \
    pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                 \
    if (unlikely (pos_x > decoder->limit_x)) {                    \
    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
    motion_x = pos_x - 2 * decoder->offset;                   \
    }                                         \
    if (unlikely (pos_y > decoder->limit_y_ ## size)) {               \
    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;         \
    motion_y = pos_y - 2 * decoder->v_offset - 2 * y;             \
    }                                         \
    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                   \
    offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride;           \
    table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
            ref[0] + offset, decoder->stride, size);              \
    table[xy_half] (decoder->dest[1] + y * decoder->stride + decoder->offset, \
            ref[1] + offset, decoder->stride, size);              \
    table[xy_half] (decoder->dest[2] + y * decoder->stride + decoder->offset, \
            ref[2] + offset, decoder->stride, size)

#define MOTION_CALL ( routine,
direction   ) 

Value:

do {                                \
    if ((direction) & MACROBLOCK_MOTION_FORWARD)        \
    routine (decoder, &(decoder->f_motion), mpeg2_mc.put);  \
    if ((direction) & MACROBLOCK_MOTION_BACKWARD)       \
    routine (decoder, &(decoder->b_motion),         \
         ((direction) & MACROBLOCK_MOTION_FORWARD ? \
          mpeg2_mc.avg : mpeg2_mc.put));        \
} while (0)

#define MOTION_DMV_420 ( table,
ref,
motion_x,
motion_y   ) 

#define MOTION_DMV_422 ( table,
ref,
motion_x,
motion_y   ) 

#define MOTION_DMV_444 ( table,
ref,
motion_x,
motion_y   ) 

Value:

pos_x = 2 * decoder->offset + motion_x;                   \
    pos_y = decoder->v_offset + motion_y;                     \
    if (unlikely (pos_x > decoder->limit_x)) {                    \
    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
    motion_x = pos_x - 2 * decoder->offset;                   \
    }                                         \
    if (unlikely (pos_y > decoder->limit_y)) {                    \
    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
    motion_y = pos_y - decoder->v_offset;                     \
    }                                         \
    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                   \
    offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;           \
    table[xy_half] (decoder->dest[0] + decoder->offset,               \
            ref[0] + offset, 2 * decoder->stride, 8);             \
    table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset,     \
            ref[0] + decoder->stride + offset,                \
            2 * decoder->stride, 8);                      \
    table[xy_half] (decoder->dest[1] + decoder->offset,               \
            ref[1] + offset, 2 * decoder->stride, 8);             \
    table[xy_half] (decoder->dest[1] + decoder->stride + decoder->offset,     \
            ref[1] + decoder->stride + offset,                \
            2 * decoder->stride, 8);                      \
    table[xy_half] (decoder->dest[2] + decoder->offset,               \
            ref[2] + offset, 2 * decoder->stride, 8);             \
    table[xy_half] (decoder->dest[2] + decoder->stride + decoder->offset,     \
            ref[2] + decoder->stride + offset,                \
            2 * decoder->stride, 8)

#define MOTION_FIELD_420 ( table,
ref,
motion_x,
motion_y,
dest_field,
op,
src_field   ) 

Value:

pos_x = 2 * decoder->offset + motion_x;                   \
    pos_y = decoder->v_offset + motion_y;                     \
    if (unlikely (pos_x > decoder->limit_x)) {                    \
    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
    motion_x = pos_x - 2 * decoder->offset;                   \
    }                                         \
    if (unlikely (pos_y > decoder->limit_y)) {                    \
    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
    motion_y = pos_y - decoder->v_offset;                     \
    }                                         \
    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                   \
    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +         \
            decoder->offset,                          \
            (ref[0] + (pos_x >> 1) +                      \
             ((pos_y op) + src_field) * decoder->stride),         \
            2 * decoder->stride, 8);                      \
    motion_x /= 2;  motion_y /= 2;                        \
    xy_half = ((motion_y & 1) << 1) | (motion_x & 1);                 \
    offset = (((decoder->offset + motion_x) >> 1) +               \
          (((decoder->v_offset >> 1) + (motion_y op) + src_field) *       \
           decoder->uv_stride));                          \
    table[4+xy_half] (decoder->dest[1] + dest_field * decoder->uv_stride +    \
              (decoder->offset >> 1), ref[1] + offset,            \
              2 * decoder->uv_stride, 4);                 \
    table[4+xy_half] (decoder->dest[2] + dest_field * decoder->uv_stride +    \
              (decoder->offset >> 1), ref[2] + offset,            \
              2 * decoder->uv_stride, 4)

#define MOTION_FIELD_422 ( table,
ref,
motion_x,
motion_y,
dest_field,
op,
src_field   ) 

Value:

pos_x = 2 * decoder->offset + motion_x;                   \
    pos_y = decoder->v_offset + motion_y;                     \
    if (unlikely (pos_x > decoder->limit_x)) {                    \
    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
    motion_x = pos_x - 2 * decoder->offset;                   \
    }                                         \
    if (unlikely (pos_y > decoder->limit_y)) {                    \
    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
    motion_y = pos_y - decoder->v_offset;                     \
    }                                         \
    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                   \
    offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride;       \
    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +         \
            decoder->offset, ref[0] + offset,                 \
            2 * decoder->stride, 8);                      \
    offset = (offset + (motion_x & (motion_x < 0))) >> 1;             \
    motion_x /= 2;                                \
    xy_half = ((pos_y & 1) << 1) | (motion_x & 1);                \
    table[4+xy_half] (decoder->dest[1] + dest_field * decoder->uv_stride +    \
              (decoder->offset >> 1), ref[1] + offset,            \
              2 * decoder->uv_stride, 8);                 \
    table[4+xy_half] (decoder->dest[2] + dest_field * decoder->uv_stride +    \
              (decoder->offset >> 1), ref[2] + offset,            \
              2 * decoder->uv_stride, 8)

#define MOTION_FIELD_444 ( table,
ref,
motion_x,
motion_y,
dest_field,
op,
src_field   ) 

Value:

pos_x = 2 * decoder->offset + motion_x;                   \
    pos_y = decoder->v_offset + motion_y;                     \
    if (unlikely (pos_x > decoder->limit_x)) {                    \
    pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;              \
    motion_x = pos_x - 2 * decoder->offset;                   \
    }                                         \
    if (unlikely (pos_y > decoder->limit_y)) {                    \
    pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;              \
    motion_y = pos_y - decoder->v_offset;                     \
    }                                         \
    xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                   \
    offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride;       \
    table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +         \
            decoder->offset, ref[0] + offset,                 \
            2 * decoder->stride, 8);                      \
    table[xy_half] (decoder->dest[1] + dest_field * decoder->stride +         \
            decoder->offset, ref[1] + offset,                 \
            2 * decoder->stride, 8);                      \
    table[xy_half] (decoder->dest[2] + dest_field * decoder->stride +         \
            decoder->offset, ref[2] + offset,                 \
            2 * decoder->stride, 8)

#define MOTION_FUNCTIONS ( FORMAT,
MOTION,
MOTION_FIELD,
MOTION_DMV,
MOTION_ZERO   ) 

#define MOTION_ZERO_420 ( table,
ref   ) 

Value:

table[0] (decoder->dest[0] + decoder->offset,                 \
          (ref[0] + decoder->offset +                     \
           decoder->v_offset * decoder->stride), decoder->stride, 16);    \
    offset = ((decoder->offset >> 1) +                        \
          (decoder->v_offset >> 1) * decoder->uv_stride);             \
    table[4] (decoder->dest[1] + (decoder->offset >> 1),              \
          ref[1] + offset, decoder->uv_stride, 8);                \
    table[4] (decoder->dest[2] + (decoder->offset >> 1),              \
          ref[2] + offset, decoder->uv_stride, 8)

#define MOTION_ZERO_422 ( table,
ref   ) 

Value:

offset = decoder->offset + decoder->v_offset * decoder->stride;       \
    table[0] (decoder->dest[0] + decoder->offset,                 \
          ref[0] + offset, decoder->stride, 16);                  \
    offset >>= 1;                                 \
    table[4] (decoder->dest[1] + (decoder->offset >> 1),              \
          ref[1] + offset, decoder->uv_stride, 16);               \
    table[4] (decoder->dest[2] + (decoder->offset >> 1),              \
          ref[2] + offset, decoder->uv_stride, 16)

#define MOTION_ZERO_444 ( table,
ref   ) 

Value:

offset = decoder->offset + decoder->v_offset * decoder->stride;       \
    table[0] (decoder->dest[0] + decoder->offset,                 \
          ref[0] + offset, decoder->stride, 16);                  \
    table[4] (decoder->dest[1] + decoder->offset,                 \
          ref[1] + offset, decoder->stride, 16);                  \
    table[4] (decoder->dest[2] + (decoder->offset >> 1),              \
          ref[2] + offset, decoder->stride, 16)

#define NEXT_MACROBLOCK

Value:

do {                                    \
    decoder->offset += 16;                      \
    if (decoder->offset == decoder->width) {                \
    do { /* just so we can use the break statement */       \
        if (decoder->convert) {                 \
        decoder->convert (decoder->convert_id, decoder->dest,   \
                  decoder->v_offset);           \
        if (decoder->coding_type == B_TYPE)         \
            break;                      \
        }                               \
        decoder->dest[0] += decoder->slice_stride;          \
        decoder->dest[1] += decoder->slice_uv_stride;       \
        decoder->dest[2] += decoder->slice_uv_stride;       \
    } while (0);                            \
    decoder->v_offset += 16;                    \
    if (decoder->v_offset > decoder->limit_y) {         \
        if (mpeg2_cpu_state_restore)                \
        mpeg2_cpu_state_restore (&cpu_state);           \
        return;                         \
    }                               \
    decoder->offset = 0;                        \
    }                                   \
} while (0)

Function Documentation

static __attribute__ ( (__always_inline__)   )  [static]

static void motion_fi_16x8_420 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fi_16x8_422 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fi_16x8_444 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fi_conceal ( mpeg2_decoder_t *const   decoder  )  [static]

static void motion_fi_dmv_420 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fi_dmv_422 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fi_dmv_444 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fi_field_420 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fi_field_422 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fi_field_444 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_conceal ( mpeg2_decoder_t *const   decoder  )  [static]

static void motion_fr_dmv_420 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_dmv_422 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_dmv_444 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_field_420 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_field_422 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_field_444 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_frame_420 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_frame_422 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_fr_frame_444 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_mp1 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_reuse_420 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_reuse_422 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_reuse_444 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_zero_420 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_zero_422 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

static void motion_zero_444 ( mpeg2_decoder_t *const   decoder,
motion_t *const  motion,
mpeg2_mc_fct *const *const  table 
) [static]

void mpeg2_init_fbuf ( mpeg2_decoder_t *  decoder,
uint8_t *  current_fbuf[3],
uint8_t *  forward_fbuf[3],
uint8_t *  backward_fbuf[3] 
)

Variable Documentation

void(* ) mpeg2_cpu_state_restore(cpu_state_t *state)

void(* ) mpeg2_cpu_state_save(cpu_state_t *state)

mpeg2_mc_t mpeg2_mc

Generated on Wed Aug 13 08:03:19 2008 for VLC by  doxygen 1.5.1