git.sesse.net Git - vlc/blob - modules/codec/xvmc/slice.c

   1 /* $Id$
   2  * slice.c
   3  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
   4  * Copyright (C) 2003      Peter Gubanov <peter@elecard.net.ru>
   5  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
   6  *
   7  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
   8  * See http://libmpeg2.sourceforge.net/ for updates.
   9  *
  10  * mpeg2dec is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * mpeg2dec is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include "xxmc-config.h"
  26
  27 #include <inttypes.h>
  28
  29 #include "mpeg2.h"
  30 #include "attributes.h"
  31 #include "mpeg2_internal.h"
  32
  33 extern mpeg2_mc_t mpeg2_mc;
  34 extern void (* mpeg2_cpu_state_save) (cpu_state_t * state);
  35 extern void (* mpeg2_cpu_state_restore) (cpu_state_t * state);
  36
  37 #include "vlc.h"
  38
  39 static inline int get_motion_delta( mpeg2_decoder_t * const decoder,
  40                                     const int f_code )
  41 {
  42 #define bit_buf (decoder->bitstream_buf)
  43 #define bits (decoder->bitstream_bits)
  44 #define bit_ptr (decoder->bitstream_ptr)
  45
  46     int delta;
  47     int sign;
  48     const MVtab * tab;
  49
  50     if( bit_buf & 0x80000000 )
  51     {
  52         DUMPBITS (bit_buf, bits, 1);
  53         return 0;
  54     }
  55     else if (bit_buf >= 0x0c000000)
  56     {
  57         tab = MV_4 + UBITS (bit_buf, 4);
  58         delta = (tab->delta << f_code) + 1;
  59         bits += tab->len + f_code + 1;
  60         bit_buf <<= tab->len;
  61
  62         sign = SBITS (bit_buf, 1);
  63         bit_buf <<= 1;
  64
  65         if (f_code)
  66             delta += UBITS (bit_buf, f_code);
  67         bit_buf <<= f_code;
  68         return (delta ^ sign) - sign;
  69     }
  70     else
  71     {
  72         tab = MV_10 + UBITS (bit_buf, 10);
  73         delta = (tab->delta << f_code) + 1;
  74         bits += tab->len + 1;
  75         bit_buf <<= tab->len;
  76
  77         sign = SBITS (bit_buf, 1);
  78         bit_buf <<= 1;
  79
  80         if (f_code)
  81         {
  82             NEEDBITS (bit_buf, bits, bit_ptr);
  83             delta += UBITS (bit_buf, f_code);
  84             DUMPBITS (bit_buf, bits, f_code);
  85         }
  86
  87         return (delta ^ sign) - sign;
  88     }
  89 #undef bit_buf
  90 #undef bits
  91 #undef bit_ptr
  92 }
  93
  94 static inline int bound_motion_vector (const int vector, const int f_code)
  95 {
  96     return ((int32_t)vector << (27 - f_code)) >> (27 - f_code);
  97 }
  98
  99 static inline int get_dmv (mpeg2_decoder_t * const decoder)
 100 {
 101 #define bit_buf (decoder->bitstream_buf)
 102 #define bits (decoder->bitstream_bits)
 103 #define bit_ptr (decoder->bitstream_ptr)
 104
 105     const DMVtab * tab;
 106
 107     tab = DMV_2 + UBITS (bit_buf, 2);
 108     DUMPBITS (bit_buf, bits, tab->len);
 109     return tab->dmv;
 110 #undef bit_buf
 111 #undef bits
 112 #undef bit_ptr
 113 }
 114
 115 #define MOTION_420(table,ref,motion_x,motion_y,size,y)                        \
 116     pos_x = 2 * decoder->offset + motion_x;                                   \
 117     pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                         \
 118     if (unlikely (pos_x > decoder->limit_x)) {                                \
 119         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 120         motion_x = pos_x - 2 * decoder->offset;                               \
 121     }                                                                         \
 122     if (unlikely (pos_y > decoder->limit_y_ ## size)) {                       \
 123         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;             \
 124         motion_y = pos_y - 2 * decoder->v_offset - 2 * y;                     \
 125     }                                                                         \
 126     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 127     table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
 128                     ref[0] + (pos_x >> 1) + (pos_y >> 1) * decoder->stride,   \
 129                     decoder->stride, size);                                   \
 130     motion_x /= 2;      motion_y /= 2;                                        \
 131     xy_half = ((motion_y & 1) << 1) | (motion_x & 1);                         \
 132     offset = (((decoder->offset + motion_x) >> 1) +                           \
 133               ((((decoder->v_offset + motion_y) >> 1) + y/2) *                \
 134                decoder->uv_stride));                                          \
 135     table[4+xy_half] (decoder->dest[1] + y/2 * decoder->uv_stride +           \
 136                       (decoder->offset >> 1), ref[1] + offset,                \
 137                       decoder->uv_stride, size/2);                            \
 138     table[4+xy_half] (decoder->dest[2] + y/2 * decoder->uv_stride +           \
 139                       (decoder->offset >> 1), ref[2] + offset,                \
 140                       decoder->uv_stride, size/2)
 141
 142 #define MOTION_FIELD_420(table,ref,motion_x,motion_y,dest_field,op,src_field) \
 143     pos_x = 2 * decoder->offset + motion_x;                                   \
 144     pos_y = decoder->v_offset + motion_y;                                     \
 145     if (unlikely (pos_x > decoder->limit_x)) {                                \
 146         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 147         motion_x = pos_x - 2 * decoder->offset;                               \
 148     }                                                                         \
 149     if (unlikely (pos_y > decoder->limit_y)) {                                \
 150         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;                      \
 151         motion_y = pos_y - decoder->v_offset;                                 \
 152     }                                                                         \
 153     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 154     table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +         \
 155                     decoder->offset,                                          \
 156                     (ref[0] + (pos_x >> 1) +                                  \
 157                      ((pos_y op) + src_field) * decoder->stride),             \
 158                     2 * decoder->stride, 8);                                  \
 159     motion_x /= 2;      motion_y /= 2;                                        \
 160     xy_half = ((motion_y & 1) << 1) | (motion_x & 1);                         \
 161     offset = (((decoder->offset + motion_x) >> 1) +                           \
 162               (((decoder->v_offset >> 1) + (motion_y op) + src_field) *       \
 163                decoder->uv_stride));                                          \
 164     table[4+xy_half] (decoder->dest[1] + dest_field * decoder->uv_stride +    \
 165                       (decoder->offset >> 1), ref[1] + offset,                \
 166                       2 * decoder->uv_stride, 4);                             \
 167     table[4+xy_half] (decoder->dest[2] + dest_field * decoder->uv_stride +    \
 168                       (decoder->offset >> 1), ref[2] + offset,                \
 169                       2 * decoder->uv_stride, 4)
 170
 171 #define MOTION_DMV_420(table,ref,motion_x,motion_y)                           \
 172     pos_x = 2 * decoder->offset + motion_x;                                   \
 173     pos_y = decoder->v_offset + motion_y;                                     \
 174     if (unlikely (pos_x > decoder->limit_x)) {                                \
 175         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 176         motion_x = pos_x - 2 * decoder->offset;                               \
 177     }                                                                         \
 178     if (unlikely (pos_y > decoder->limit_y)) {                                \
 179         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;                      \
 180         motion_y = pos_y - decoder->v_offset;                                 \
 181     }                                                                         \
 182     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 183     offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;                   \
 184     table[xy_half] (decoder->dest[0] + decoder->offset,                       \
 185                     ref[0] + offset, 2 * decoder->stride, 8);                 \
 186     table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset,     \
 187                     ref[0] + decoder->stride + offset,                        \
 188                     2 * decoder->stride, 8);                                  \
 189     motion_x /= 2;      motion_y /= 2;                                        \
 190     xy_half = ((motion_y & 1) << 1) | (motion_x & 1);                         \
 191     offset = (((decoder->offset + motion_x) >> 1) +                           \
 192               (((decoder->v_offset >> 1) + (motion_y & ~1)) *                 \
 193                decoder->uv_stride));                                          \
 194     table[4+xy_half] (decoder->dest[1] + (decoder->offset >> 1),              \
 195                       ref[1] + offset, 2 * decoder->uv_stride, 4);            \
 196     table[4+xy_half] (decoder->dest[1] + decoder->uv_stride +                 \
 197                       (decoder->offset >> 1),                                 \
 198                       ref[1] + decoder->uv_stride + offset,                   \
 199                       2 * decoder->uv_stride, 4);                             \
 200     table[4+xy_half] (decoder->dest[2] + (decoder->offset >> 1),              \
 201                       ref[2] + offset, 2 * decoder->uv_stride, 4);            \
 202     table[4+xy_half] (decoder->dest[2] + decoder->uv_stride +                 \
 203                       (decoder->offset >> 1),                                 \
 204                       ref[2] + decoder->uv_stride + offset,                   \
 205                       2 * decoder->uv_stride, 4)
 206
 207 #define MOTION_ZERO_420(table,ref)                                            \
 208     table[0] (decoder->dest[0] + decoder->offset,                             \
 209               (ref[0] + decoder->offset +                                     \
 210                decoder->v_offset * decoder->stride), decoder->stride, 16);    \
 211     offset = ((decoder->offset >> 1) +                                        \
 212               (decoder->v_offset >> 1) * decoder->uv_stride);                 \
 213     table[4] (decoder->dest[1] + (decoder->offset >> 1),                      \
 214               ref[1] + offset, decoder->uv_stride, 8);                        \
 215     table[4] (decoder->dest[2] + (decoder->offset >> 1),                      \
 216               ref[2] + offset, decoder->uv_stride, 8)
 217
 218 #define MOTION_422(table,ref,motion_x,motion_y,size,y)                        \
 219     pos_x = 2 * decoder->offset + motion_x;                                   \
 220     pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                         \
 221     if (unlikely (pos_x > decoder->limit_x)) {                                \
 222         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 223         motion_x = pos_x - 2 * decoder->offset;                               \
 224     }                                                                         \
 225     if (unlikely (pos_y > decoder->limit_y_ ## size)) {                       \
 226         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;             \
 227         motion_y = pos_y - 2 * decoder->v_offset - 2 * y;                     \
 228     }                                                                         \
 229     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 230     offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride;                   \
 231     table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
 232                     ref[0] + offset, decoder->stride, size);                  \
 233     offset = (offset + (motion_x & (motion_x < 0))) >> 1;                     \
 234     motion_x /= 2;                                                            \
 235     xy_half = ((pos_y & 1) << 1) | (motion_x & 1);                            \
 236     table[4+xy_half] (decoder->dest[1] + y * decoder->uv_stride +             \
 237                       (decoder->offset >> 1), ref[1] + offset,                \
 238                       decoder->uv_stride, size);                              \
 239     table[4+xy_half] (decoder->dest[2] + y * decoder->uv_stride +             \
 240                       (decoder->offset >> 1), ref[2] + offset,                \
 241                       decoder->uv_stride, size)
 242
 243 #define MOTION_FIELD_422(table,ref,motion_x,motion_y,dest_field,op,src_field) \
 244     pos_x = 2 * decoder->offset + motion_x;                                   \
 245     pos_y = decoder->v_offset + motion_y;                                     \
 246     if (unlikely (pos_x > decoder->limit_x)) {                                \
 247         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 248         motion_x = pos_x - 2 * decoder->offset;                               \
 249     }                                                                         \
 250     if (unlikely (pos_y > decoder->limit_y)) {                                \
 251         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;                      \
 252         motion_y = pos_y - decoder->v_offset;                                 \
 253     }                                                                         \
 254     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 255     offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride;       \
 256     table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +         \
 257                     decoder->offset, ref[0] + offset,                         \
 258                     2 * decoder->stride, 8);                                  \
 259     offset = (offset + (motion_x & (motion_x < 0))) >> 1;                     \
 260     motion_x /= 2;                                                            \
 261     xy_half = ((pos_y & 1) << 1) | (motion_x & 1);                            \
 262     table[4+xy_half] (decoder->dest[1] + dest_field * decoder->uv_stride +    \
 263                       (decoder->offset >> 1), ref[1] + offset,                \
 264                       2 * decoder->uv_stride, 8);                             \
 265     table[4+xy_half] (decoder->dest[2] + dest_field * decoder->uv_stride +    \
 266                       (decoder->offset >> 1), ref[2] + offset,                \
 267                       2 * decoder->uv_stride, 8)
 268
 269 #define MOTION_DMV_422(table,ref,motion_x,motion_y)                           \
 270     pos_x = 2 * decoder->offset + motion_x;                                   \
 271     pos_y = decoder->v_offset + motion_y;                                     \
 272     if (unlikely (pos_x > decoder->limit_x)) {                                \
 273         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 274         motion_x = pos_x - 2 * decoder->offset;                               \
 275     }                                                                         \
 276     if (unlikely (pos_y > decoder->limit_y)) {                                \
 277         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;                      \
 278         motion_y = pos_y - decoder->v_offset;                                 \
 279     }                                                                         \
 280     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 281     offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;                   \
 282     table[xy_half] (decoder->dest[0] + decoder->offset,                       \
 283                     ref[0] + offset, 2 * decoder->stride, 8);                 \
 284     table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset,     \
 285                     ref[0] + decoder->stride + offset,                        \
 286                     2 * decoder->stride, 8);                                  \
 287     offset = (offset + (motion_x & (motion_x < 0))) >> 1;                     \
 288     motion_x /= 2;                                                            \
 289     xy_half = ((pos_y & 1) << 1) | (motion_x & 1);                            \
 290     table[4+xy_half] (decoder->dest[1] + (decoder->offset >> 1),              \
 291                       ref[1] + offset, 2 * decoder->uv_stride, 8);            \
 292     table[4+xy_half] (decoder->dest[1] + decoder->uv_stride +                 \
 293                       (decoder->offset >> 1),                                 \
 294                       ref[1] + decoder->uv_stride + offset,                   \
 295                       2 * decoder->uv_stride, 8);                             \
 296     table[4+xy_half] (decoder->dest[2] + (decoder->offset >> 1),              \
 297                       ref[2] + offset, 2 * decoder->uv_stride, 8);            \
 298     table[4+xy_half] (decoder->dest[2] + decoder->uv_stride +                 \
 299                       (decoder->offset >> 1),                                 \
 300                       ref[2] + decoder->uv_stride + offset,                   \
 301                       2 * decoder->uv_stride, 8)
 302
 303 #define MOTION_ZERO_422(table,ref)                                            \
 304     offset = decoder->offset + decoder->v_offset * decoder->stride;           \
 305     table[0] (decoder->dest[0] + decoder->offset,                             \
 306               ref[0] + offset, decoder->stride, 16);                          \
 307     offset >>= 1;                                                             \
 308     table[4] (decoder->dest[1] + (decoder->offset >> 1),                      \
 309               ref[1] + offset, decoder->uv_stride, 16);                       \
 310     table[4] (decoder->dest[2] + (decoder->offset >> 1),                      \
 311               ref[2] + offset, decoder->uv_stride, 16)
 312
 313 #define MOTION_444(table,ref,motion_x,motion_y,size,y)                        \
 314     pos_x = 2 * decoder->offset + motion_x;                                   \
 315     pos_y = 2 * decoder->v_offset + motion_y + 2 * y;                         \
 316     if (unlikely (pos_x > decoder->limit_x)) {                                \
 317         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 318         motion_x = pos_x - 2 * decoder->offset;                               \
 319     }                                                                         \
 320     if (unlikely (pos_y > decoder->limit_y_ ## size)) {                       \
 321         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y_ ## size;             \
 322         motion_y = pos_y - 2 * decoder->v_offset - 2 * y;                     \
 323     }                                                                         \
 324     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 325     offset = (pos_x >> 1) + (pos_y >> 1) * decoder->stride;                   \
 326     table[xy_half] (decoder->dest[0] + y * decoder->stride + decoder->offset, \
 327                     ref[0] + offset, decoder->stride, size);                  \
 328     table[xy_half] (decoder->dest[1] + y * decoder->stride + decoder->offset, \
 329                     ref[1] + offset, decoder->stride, size);                  \
 330     table[xy_half] (decoder->dest[2] + y * decoder->stride + decoder->offset, \
 331                     ref[2] + offset, decoder->stride, size)
 332
 333 #define MOTION_FIELD_444(table,ref,motion_x,motion_y,dest_field,op,src_field) \
 334     pos_x = 2 * decoder->offset + motion_x;                                   \
 335     pos_y = decoder->v_offset + motion_y;                                     \
 336     if (unlikely (pos_x > decoder->limit_x)) {                                \
 337         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 338         motion_x = pos_x - 2 * decoder->offset;                               \
 339     }                                                                         \
 340     if (unlikely (pos_y > decoder->limit_y)) {                                \
 341         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;                      \
 342         motion_y = pos_y - decoder->v_offset;                                 \
 343     }                                                                         \
 344     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 345     offset = (pos_x >> 1) + ((pos_y op) + src_field) * decoder->stride;       \
 346     table[xy_half] (decoder->dest[0] + dest_field * decoder->stride +         \
 347                     decoder->offset, ref[0] + offset,                         \
 348                     2 * decoder->stride, 8);                                  \
 349     table[xy_half] (decoder->dest[1] + dest_field * decoder->stride +         \
 350                     decoder->offset, ref[1] + offset,                         \
 351                     2 * decoder->stride, 8);                                  \
 352     table[xy_half] (decoder->dest[2] + dest_field * decoder->stride +         \
 353                     decoder->offset, ref[2] + offset,                         \
 354                     2 * decoder->stride, 8)
 355
 356 #define MOTION_DMV_444(table,ref,motion_x,motion_y)                           \
 357     pos_x = 2 * decoder->offset + motion_x;                                   \
 358     pos_y = decoder->v_offset + motion_y;                                     \
 359     if (unlikely (pos_x > decoder->limit_x)) {                                \
 360         pos_x = ((int)pos_x < 0) ? 0 : decoder->limit_x;                      \
 361         motion_x = pos_x - 2 * decoder->offset;                               \
 362     }                                                                         \
 363     if (unlikely (pos_y > decoder->limit_y)) {                                \
 364         pos_y = ((int)pos_y < 0) ? 0 : decoder->limit_y;                      \
 365         motion_y = pos_y - decoder->v_offset;                                 \
 366     }                                                                         \
 367     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);                               \
 368     offset = (pos_x >> 1) + (pos_y & ~1) * decoder->stride;                   \
 369     table[xy_half] (decoder->dest[0] + decoder->offset,                       \
 370                     ref[0] + offset, 2 * decoder->stride, 8);                 \
 371     table[xy_half] (decoder->dest[0] + decoder->stride + decoder->offset,     \
 372                     ref[0] + decoder->stride + offset,                        \
 373                     2 * decoder->stride, 8);                                  \
 374     table[xy_half] (decoder->dest[1] + decoder->offset,                       \
 375                     ref[1] + offset, 2 * decoder->stride, 8);                 \
 376     table[xy_half] (decoder->dest[1] + decoder->stride + decoder->offset,     \
 377                     ref[1] + decoder->stride + offset,                        \
 378                     2 * decoder->stride, 8);                                  \
 379     table[xy_half] (decoder->dest[2] + decoder->offset,                       \
 380                     ref[2] + offset, 2 * decoder->stride, 8);                 \
 381     table[xy_half] (decoder->dest[2] + decoder->stride + decoder->offset,     \
 382                     ref[2] + decoder->stride + offset,                        \
 383                     2 * decoder->stride, 8)
 384
 385 #define MOTION_ZERO_444(table,ref)                                            \
 386     offset = decoder->offset + decoder->v_offset * decoder->stride;           \
 387     table[0] (decoder->dest[0] + decoder->offset,                             \
 388               ref[0] + offset, decoder->stride, 16);                          \
 389     table[4] (decoder->dest[1] + decoder->offset,                             \
 390               ref[1] + offset, decoder->stride, 16);                          \
 391     table[4] (decoder->dest[2] + (decoder->offset >> 1),                      \
 392               ref[2] + offset, decoder->stride, 16)
 393
 394 #define bit_buf (decoder->bitstream_buf)
 395 #define bits (decoder->bitstream_bits)
 396 #define bit_ptr (decoder->bitstream_ptr)
 397
 398 static void motion_mp1 (mpeg2_decoder_t * const decoder,
 399                         motion_t * const motion,
 400                         mpeg2_mc_fct * const * const table)
 401 {
 402     int motion_x, motion_y;
 403     unsigned int pos_x, pos_y, xy_half, offset;
 404
 405     NEEDBITS (bit_buf, bits, bit_ptr);
 406     motion_x = (motion->pmv[0][0] +
 407                (get_motion_delta( decoder,
 408                                   motion->f_code[0] ) << motion->f_code[1]));
 409     motion_x = bound_motion_vector( motion_x,
 410                                     motion->f_code[0] + motion->f_code[1]);
 411     motion->pmv[0][0] = motion_x;
 412
 413     NEEDBITS (bit_buf, bits, bit_ptr);
 414     motion_y = (motion->pmv[0][1] +
 415                (get_motion_delta( decoder,
 416                                   motion->f_code[0]) << motion->f_code[1]));
 417     motion_y = bound_motion_vector( motion_y,
 418                                     motion->f_code[0] + motion->f_code[1]);
 419     motion->pmv[0][1] = motion_y;
 420     MOTION_420 (table, motion->ref[0], motion_x, motion_y, 16, 0);
 421 }
 422
 423 #define MOTION_FUNCTIONS(FORMAT,MOTION,MOTION_FIELD,MOTION_DMV,MOTION_ZERO)   \
 424                                                                               \
 425 static void motion_fr_frame_##FORMAT (mpeg2_decoder_t * const decoder,        \
 426                                       motion_t * const motion,                \
 427                                       mpeg2_mc_fct * const * const table)     \
 428 {                                                                             \
 429     int motion_x, motion_y;                                                   \
 430     unsigned int pos_x, pos_y, xy_half, offset;                               \
 431                                                                               \
 432     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 433     motion_x = motion->pmv[0][0] + get_motion_delta (decoder,                 \
 434                                                      motion->f_code[0]);      \
 435     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);             \
 436     motion->pmv[1][0] = motion->pmv[0][0] = motion_x;                         \
 437                                                                               \
 438     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 439     motion_y = motion->pmv[0][1] + get_motion_delta (decoder,                 \
 440                                                      motion->f_code[1]);      \
 441     motion_y = bound_motion_vector (motion_y, motion->f_code[1]);             \
 442     motion->pmv[1][1] = motion->pmv[0][1] = motion_y;                         \
 443                                                                               \
 444     MOTION (table, motion->ref[0], motion_x, motion_y, 16, 0);                \
 445 }                                                                             \
 446                                                                               \
 447 static void motion_fr_field_##FORMAT (mpeg2_decoder_t * const decoder,        \
 448                                       motion_t * const motion,                \
 449                                       mpeg2_mc_fct * const * const table)     \
 450 {                                                                             \
 451     int motion_x, motion_y, field;                                            \
 452     unsigned int pos_x, pos_y, xy_half, offset;                               \
 453                                                                               \
 454     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 455     field = UBITS (bit_buf, 1);                                               \
 456     DUMPBITS (bit_buf, bits, 1);                                              \
 457                                                                               \
 458     motion_x = motion->pmv[0][0] + get_motion_delta (decoder,                 \
 459                                                      motion->f_code[0]);      \
 460     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);             \
 461     motion->pmv[0][0] = motion_x;                                             \
 462                                                                               \
 463     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 464     motion_y = ((motion->pmv[0][1] >> 1) +                                    \
 465                 get_motion_delta (decoder, motion->f_code[1]));               \
 466     /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */       \
 467     motion->pmv[0][1] = motion_y << 1;                                        \
 468                                                                               \
 469     MOTION_FIELD (table, motion->ref[0], motion_x, motion_y, 0, & ~1, field); \
 470                                                                               \
 471     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 472     field = UBITS (bit_buf, 1);                                               \
 473     DUMPBITS (bit_buf, bits, 1);                                              \
 474                                                                               \
 475     motion_x = motion->pmv[1][0] + get_motion_delta (decoder,                 \
 476                                                      motion->f_code[0]);      \
 477     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);             \
 478     motion->pmv[1][0] = motion_x;                                             \
 479                                                                               \
 480     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 481     motion_y = ((motion->pmv[1][1] >> 1) +                                    \
 482                 get_motion_delta (decoder, motion->f_code[1]));               \
 483     /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */       \
 484     motion->pmv[1][1] = motion_y << 1;                                        \
 485                                                                               \
 486     MOTION_FIELD (table, motion->ref[0], motion_x, motion_y, 1, & ~1, field); \
 487 }                                                                             \
 488                                                                               \
 489 static void motion_fr_dmv_##FORMAT (mpeg2_decoder_t * const decoder,          \
 490                                     motion_t * const motion,                  \
 491                                     mpeg2_mc_fct * const * const table)       \
 492 {                                                                             \
 493     int motion_x, motion_y, dmv_x, dmv_y, m, other_x, other_y;                \
 494     unsigned int pos_x, pos_y, xy_half, offset;                               \
 495                                                                               \
 496     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 497     motion_x = motion->pmv[0][0] + get_motion_delta (decoder,                 \
 498                                                      motion->f_code[0]);      \
 499     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);             \
 500     motion->pmv[1][0] = motion->pmv[0][0] = motion_x;                         \
 501     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 502     dmv_x = get_dmv (decoder);                                                \
 503                                                                               \
 504     motion_y = ((motion->pmv[0][1] >> 1) +                                    \
 505                 get_motion_delta (decoder, motion->f_code[1]));               \
 506     /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */       \
 507     motion->pmv[1][1] = motion->pmv[0][1] = motion_y << 1;                    \
 508     dmv_y = get_dmv (decoder);                                                \
 509                                                                               \
 510     m = decoder->top_field_first ? 1 : 3;                                     \
 511     other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x;                 \
 512     other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y - 1;             \
 513     MOTION_FIELD (mpeg2_mc.put, motion->ref[0], other_x, other_y, 0, | 1, 0); \
 514                                                                               \
 515     m = decoder->top_field_first ? 3 : 1;                                     \
 516     other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x;                 \
 517     other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y + 1;             \
 518     MOTION_FIELD (mpeg2_mc.put, motion->ref[0], other_x, other_y, 1, & ~1, 0);\
 519                                                                               \
 520     MOTION_DMV (mpeg2_mc.avg, motion->ref[0], motion_x, motion_y);            \
 521 }                                                                             \
 522                                                                               \
 523 static void motion_reuse_##FORMAT (mpeg2_decoder_t * const decoder,           \
 524                                    motion_t * const motion,                   \
 525                                    mpeg2_mc_fct * const * const table)        \
 526 {                                                                             \
 527     int motion_x, motion_y;                                                   \
 528     unsigned int pos_x, pos_y, xy_half, offset;                               \
 529                                                                               \
 530     motion_x = motion->pmv[0][0];                                             \
 531     motion_y = motion->pmv[0][1];                                             \
 532                                                                               \
 533     MOTION (table, motion->ref[0], motion_x, motion_y, 16, 0);                \
 534 }                                                                             \
 535                                                                               \
 536 static void motion_zero_##FORMAT (mpeg2_decoder_t * const decoder,            \
 537                                   motion_t * const motion,                    \
 538                                   mpeg2_mc_fct * const * const table)         \
 539 {                                                                             \
 540     unsigned int offset;                                                      \
 541                                                                               \
 542     motion->pmv[0][0] = motion->pmv[0][1] = 0;                                \
 543     motion->pmv[1][0] = motion->pmv[1][1] = 0;                                \
 544                                                                               \
 545     MOTION_ZERO (table, motion->ref[0]);                                      \
 546 }                                                                             \
 547                                                                               \
 548 static void motion_fi_field_##FORMAT (mpeg2_decoder_t * const decoder,        \
 549                                       motion_t * const motion,                \
 550                                       mpeg2_mc_fct * const * const table)     \
 551 {                                                                             \
 552     int motion_x, motion_y;                                                   \
 553     uint8_t ** ref_field;                                                     \
 554     unsigned int pos_x, pos_y, xy_half, offset;                               \
 555                                                                               \
 556     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 557     ref_field = motion->ref2[UBITS (bit_buf, 1)];                             \
 558     DUMPBITS (bit_buf, bits, 1);                                              \
 559                                                                               \
 560     motion_x = motion->pmv[0][0] + get_motion_delta (decoder,                 \
 561                                                      motion->f_code[0]);      \
 562     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);             \
 563     motion->pmv[1][0] = motion->pmv[0][0] = motion_x;                         \
 564                                                                               \
 565     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 566     motion_y = motion->pmv[0][1] + get_motion_delta (decoder,                 \
 567                                                      motion->f_code[1]);      \
 568     motion_y = bound_motion_vector (motion_y, motion->f_code[1]);             \
 569     motion->pmv[1][1] = motion->pmv[0][1] = motion_y;                         \
 570                                                                               \
 571     MOTION (table, ref_field, motion_x, motion_y, 16, 0);                     \
 572 }                                                                             \
 573                                                                               \
 574 static void motion_fi_16x8_##FORMAT (mpeg2_decoder_t * const decoder,         \
 575                                      motion_t * const motion,                 \
 576                                      mpeg2_mc_fct * const * const table)      \
 577 {                                                                             \
 578     int motion_x, motion_y;                                                   \
 579     uint8_t ** ref_field;                                                     \
 580     unsigned int pos_x, pos_y, xy_half, offset;                               \
 581                                                                               \
 582     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 583     ref_field = motion->ref2[UBITS (bit_buf, 1)];                             \
 584     DUMPBITS (bit_buf, bits, 1);                                              \
 585                                                                               \
 586     motion_x = motion->pmv[0][0] + get_motion_delta (decoder,                 \
 587                                                      motion->f_code[0]);      \
 588     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);             \
 589     motion->pmv[0][0] = motion_x;                                             \
 590                                                                               \
 591     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 592     motion_y = motion->pmv[0][1] + get_motion_delta (decoder,                 \
 593                                                      motion->f_code[1]);      \
 594     motion_y = bound_motion_vector (motion_y, motion->f_code[1]);             \
 595     motion->pmv[0][1] = motion_y;                                             \
 596                                                                               \
 597     MOTION (table, ref_field, motion_x, motion_y, 8, 0);                      \
 598                                                                               \
 599     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 600     ref_field = motion->ref2[UBITS (bit_buf, 1)];                             \
 601     DUMPBITS (bit_buf, bits, 1);                                              \
 602                                                                               \
 603     motion_x = motion->pmv[1][0] + get_motion_delta (decoder,                 \
 604                                                      motion->f_code[0]);      \
 605     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);             \
 606     motion->pmv[1][0] = motion_x;                                             \
 607                                                                               \
 608     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 609     motion_y = motion->pmv[1][1] + get_motion_delta (decoder,                 \
 610                                                      motion->f_code[1]);      \
 611     motion_y = bound_motion_vector (motion_y, motion->f_code[1]);             \
 612     motion->pmv[1][1] = motion_y;                                             \
 613                                                                               \
 614     MOTION (table, ref_field, motion_x, motion_y, 8, 8);                      \
 615 }                                                                             \
 616                                                                               \
 617 static void motion_fi_dmv_##FORMAT (mpeg2_decoder_t * const decoder,          \
 618                                     motion_t * const motion,                  \
 619                                     mpeg2_mc_fct * const * const table)       \
 620 {                                                                             \
 621     int motion_x, motion_y, other_x, other_y;                                 \
 622     unsigned int pos_x, pos_y, xy_half, offset;                               \
 623                                                                               \
 624     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 625     motion_x = motion->pmv[0][0] + get_motion_delta (decoder,                 \
 626                                                      motion->f_code[0]);      \
 627     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);             \
 628     motion->pmv[1][0] = motion->pmv[0][0] = motion_x;                         \
 629     NEEDBITS (bit_buf, bits, bit_ptr);                                        \
 630     other_x = ((motion_x + (motion_x > 0)) >> 1) + get_dmv (decoder);         \
 631                                                                               \
 632     motion_y = motion->pmv[0][1] + get_motion_delta (decoder,                 \
 633                                                      motion->f_code[1]);      \
 634     motion_y = bound_motion_vector (motion_y, motion->f_code[1]);             \
 635     motion->pmv[1][1] = motion->pmv[0][1] = motion_y;                         \
 636     other_y = (((motion_y + (motion_y > 0)) >> 1) + get_dmv (decoder) +       \
 637                decoder->dmv_offset);                                          \
 638                                                                               \
 639     MOTION (mpeg2_mc.put, motion->ref[0], motion_x, motion_y, 16, 0);         \
 640     MOTION (mpeg2_mc.avg, motion->ref[1], other_x, other_y, 16, 0);           \
 641 }                                                                             \
 642
 643 MOTION_FUNCTIONS (420, MOTION_420, MOTION_FIELD_420, MOTION_DMV_420,
 644                   MOTION_ZERO_420)
 645 MOTION_FUNCTIONS (422, MOTION_422, MOTION_FIELD_422, MOTION_DMV_422,
 646                   MOTION_ZERO_422)
 647 MOTION_FUNCTIONS (444, MOTION_444, MOTION_FIELD_444, MOTION_DMV_444,
 648                   MOTION_ZERO_444)
 649
 650 /* like motion_frame, but parsing without actual motion compensation */
 651 static void motion_fr_conceal (mpeg2_decoder_t * const decoder)
 652 {
 653     int tmp;
 654
 655     NEEDBITS (bit_buf, bits, bit_ptr);
 656     tmp = (decoder->f_motion.pmv[0][0] +
 657            get_motion_delta (decoder, decoder->f_motion.f_code[0]));
 658     tmp = bound_motion_vector (tmp, decoder->f_motion.f_code[0]);
 659     decoder->f_motion.pmv[1][0] = decoder->f_motion.pmv[0][0] = tmp;
 660
 661     NEEDBITS (bit_buf, bits, bit_ptr);
 662     tmp = (decoder->f_motion.pmv[0][1] +
 663            get_motion_delta (decoder, decoder->f_motion.f_code[1]));
 664     tmp = bound_motion_vector (tmp, decoder->f_motion.f_code[1]);
 665     decoder->f_motion.pmv[1][1] = decoder->f_motion.pmv[0][1] = tmp;
 666
 667     DUMPBITS (bit_buf, bits, 1); /* remove marker_bit */
 668 }
 669
 670 static void motion_fi_conceal (mpeg2_decoder_t * const decoder)
 671 {
 672     int tmp;
 673
 674     NEEDBITS (bit_buf, bits, bit_ptr);
 675     DUMPBITS (bit_buf, bits, 1); /* remove field_select */
 676
 677     tmp = (decoder->f_motion.pmv[0][0] +
 678            get_motion_delta (decoder, decoder->f_motion.f_code[0]));
 679     tmp = bound_motion_vector (tmp, decoder->f_motion.f_code[0]);
 680     decoder->f_motion.pmv[1][0] = decoder->f_motion.pmv[0][0] = tmp;
 681
 682     NEEDBITS (bit_buf, bits, bit_ptr);
 683     tmp = (decoder->f_motion.pmv[0][1] +
 684            get_motion_delta (decoder, decoder->f_motion.f_code[1]));
 685     tmp = bound_motion_vector (tmp, decoder->f_motion.f_code[1]);
 686     decoder->f_motion.pmv[1][1] = decoder->f_motion.pmv[0][1] = tmp;
 687
 688     DUMPBITS (bit_buf, bits, 1); /* remove marker_bit */
 689 }
 690
 691 #undef bit_buf
 692 #undef bits
 693 #undef bit_ptr
 694
 695 #define MOTION_CALL(routine,direction)                          \
 696 do {                                                            \
 697     if ((direction) & MACROBLOCK_MOTION_FORWARD)                \
 698         routine (decoder, &(decoder->f_motion), mpeg2_mc.put);  \
 699     if ((direction) & MACROBLOCK_MOTION_BACKWARD)               \
 700         routine (decoder, &(decoder->b_motion),                 \
 701                  ((direction) & MACROBLOCK_MOTION_FORWARD ?     \
 702                   mpeg2_mc.avg : mpeg2_mc.put));                \
 703 } while (0)
 704
 705 #define NEXT_MACROBLOCK                                                 \
 706 do {                                                                    \
 707     decoder->offset += 16;                                              \
 708     if (decoder->offset == decoder->width) {                            \
 709         do { /* just so we can use the break statement */               \
 710             if (decoder->convert) {                                     \
 711                 decoder->convert (decoder->convert_id, decoder->dest,   \
 712                                   decoder->v_offset);                   \
 713                 if (decoder->coding_type == B_TYPE)                     \
 714                     break;                                              \
 715             }                                                           \
 716             decoder->dest[0] += decoder->slice_stride;                  \
 717             decoder->dest[1] += decoder->slice_uv_stride;               \
 718             decoder->dest[2] += decoder->slice_uv_stride;               \
 719         } while (0);                                                    \
 720         decoder->v_offset += 16;                                        \
 721         if (decoder->v_offset > decoder->limit_y) {                     \
 722             if (mpeg2_cpu_state_restore)                                \
 723                 mpeg2_cpu_state_restore (&cpu_state);                   \
 724             return;                                                     \
 725         }                                                               \
 726         decoder->offset = 0;                                            \
 727     }                                                                   \
 728 } while (0)
 729
 730 void mpeg2_init_fbuf (mpeg2_decoder_t * decoder, uint8_t * current_fbuf[3],
 731                       uint8_t * forward_fbuf[3], uint8_t * backward_fbuf[3])
 732 {
 733     int offset, stride, height, bottom_field;
 734
 735     stride = decoder->stride_frame;
 736     bottom_field = (decoder->picture_structure == BOTTOM_FIELD);
 737     offset = bottom_field ? stride : 0;
 738     height = decoder->height;
 739
 740     decoder->picture_dest[0] = current_fbuf[0] + offset;
 741     decoder->picture_dest[1] = current_fbuf[1] + (offset >> 1);
 742     decoder->picture_dest[2] = current_fbuf[2] + (offset >> 1);
 743
 744     decoder->f_motion.ref[0][0] = forward_fbuf[0] + offset;
 745     decoder->f_motion.ref[0][1] = forward_fbuf[1] + (offset >> 1);
 746     decoder->f_motion.ref[0][2] = forward_fbuf[2] + (offset >> 1);
 747
 748     decoder->b_motion.ref[0][0] = backward_fbuf[0] + offset;
 749     decoder->b_motion.ref[0][1] = backward_fbuf[1] + (offset >> 1);
 750     decoder->b_motion.ref[0][2] = backward_fbuf[2] + (offset >> 1);
 751
 752     if( decoder->picture_structure != FRAME_PICTURE )
 753     {
 754         decoder->dmv_offset = bottom_field ? 1 : -1;
 755         decoder->f_motion.ref2[0] = decoder->f_motion.ref[bottom_field];
 756         decoder->f_motion.ref2[1] = decoder->f_motion.ref[!bottom_field];
 757         decoder->b_motion.ref2[0] = decoder->b_motion.ref[bottom_field];
 758         decoder->b_motion.ref2[1] = decoder->b_motion.ref[!bottom_field];
 759         offset = stride - offset;
 760
 761         if( decoder->second_field && (decoder->coding_type != B_TYPE) )
 762             forward_fbuf = current_fbuf;
 763
 764         decoder->f_motion.ref[1][0] = forward_fbuf[0] + offset;
 765         decoder->f_motion.ref[1][1] = forward_fbuf[1] + (offset >> 1);
 766         decoder->f_motion.ref[1][2] = forward_fbuf[2] + (offset >> 1);
 767
 768         decoder->b_motion.ref[1][0] = backward_fbuf[0] + offset;
 769         decoder->b_motion.ref[1][1] = backward_fbuf[1] + (offset >> 1);
 770         decoder->b_motion.ref[1][2] = backward_fbuf[2] + (offset >> 1);
 771
 772         stride <<= 1;
 773         height >>= 1;
 774     }
 775
 776     decoder->stride = stride;
 777     decoder->uv_stride = stride >> 1;
 778     decoder->slice_stride = 16 * stride;
 779     decoder->slice_uv_stride =
 780     decoder->slice_stride >> (2 - decoder->chroma_format);
 781     decoder->limit_x = 2 * decoder->width - 32;
 782     decoder->limit_y_16 = 2 * height - 32;
 783     decoder->limit_y_8 = 2 * height - 16;
 784     decoder->limit_y = height - 16;
 785
 786     if( decoder->mpeg1 )
 787     {
 788         decoder->motion_parser[0] = motion_zero_420;
 789         decoder->motion_parser[MC_FRAME] = motion_mp1;
 790         decoder->motion_parser[4] = motion_reuse_420;
 791     }
 792     else if( decoder->picture_structure == FRAME_PICTURE )
 793     {
 794         if (decoder->chroma_format == 0)
 795         {
 796             decoder->motion_parser[0] = motion_zero_420;
 797             decoder->motion_parser[MC_FIELD] = motion_fr_field_420;
 798             decoder->motion_parser[MC_FRAME] = motion_fr_frame_420;
 799             decoder->motion_parser[MC_DMV] = motion_fr_dmv_420;
 800             decoder->motion_parser[4] = motion_reuse_420;
 801         }
 802         else if (decoder->chroma_format == 1)
 803         {
 804             decoder->motion_parser[0] = motion_zero_422;
 805             decoder->motion_parser[MC_FIELD] = motion_fr_field_422;
 806             decoder->motion_parser[MC_FRAME] = motion_fr_frame_422;
 807             decoder->motion_parser[MC_DMV] = motion_fr_dmv_422;
 808             decoder->motion_parser[4] = motion_reuse_422;
 809         } else
 810         {
 811             decoder->motion_parser[0] = motion_zero_444;
 812             decoder->motion_parser[MC_FIELD] = motion_fr_field_444;
 813             decoder->motion_parser[MC_FRAME] = motion_fr_frame_444;
 814             decoder->motion_parser[MC_DMV] = motion_fr_dmv_444;
 815             decoder->motion_parser[4] = motion_reuse_444;
 816         }
 817     }
 818     else
 819     {
 820         if (decoder->chroma_format == 0)
 821         {
 822             decoder->motion_parser[0] = motion_zero_420;
 823             decoder->motion_parser[MC_FIELD] = motion_fi_field_420;
 824             decoder->motion_parser[MC_16X8] = motion_fi_16x8_420;
 825             decoder->motion_parser[MC_DMV] = motion_fi_dmv_420;
 826             decoder->motion_parser[4] = motion_reuse_420;
 827         }
 828         else if (decoder->chroma_format == 1)
 829         {
 830             decoder->motion_parser[0] = motion_zero_422;
 831             decoder->motion_parser[MC_FIELD] = motion_fi_field_422;
 832             decoder->motion_parser[MC_16X8] = motion_fi_16x8_422;
 833             decoder->motion_parser[MC_DMV] = motion_fi_dmv_422;
 834             decoder->motion_parser[4] = motion_reuse_422;
 835         }
 836         else
 837         {
 838             decoder->motion_parser[0] = motion_zero_444;
 839             decoder->motion_parser[MC_FIELD] = motion_fi_field_444;
 840             decoder->motion_parser[MC_16X8] = motion_fi_16x8_444;
 841             decoder->motion_parser[MC_DMV] = motion_fi_dmv_444;
 842             decoder->motion_parser[4] = motion_reuse_444;
 843         }
 844     }
 845 }