git.sesse.net Git - ffmpeg/blob - libavcodec/h263.c

   1 /*
   2  * H263/MPEG4 backend for ffmpeg encoder and decoder
   3  * Copyright (c) 2000,2001 Gerard Lantau.
   4  * H263+ support.
   5  * Copyright (c) 2001 Juan J. Sierralta P.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21 #include "common.h"
  22 #include "dsputil.h"
  23 #include "avcodec.h"
  24 #include "mpegvideo.h"
  25 #include "h263data.h"
  26 #include "mpeg4data.h"
  27
  28 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
  29                               int n);
  30 static void h263_encode_motion(MpegEncContext * s, int val);
  31 static void h263p_encode_umotion(MpegEncContext * s, int val);
  32 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
  33                                int n);
  34 static int h263_decode_motion(MpegEncContext * s, int pred);
  35 static int h263p_decode_umotion(MpegEncContext * s, int pred);
  36 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
  37                              int n, int coded);
  38 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  39                               int n, int coded);
  40
  41 int h263_get_picture_format(int width, int height)
  42 {
  43     int format;
  44
  45     if (width == 128 && height == 96)
  46         format = 1;
  47     else if (width == 176 && height == 144)
  48         format = 2;
  49     else if (width == 352 && height == 288)
  50         format = 3;
  51     else if (width == 704 && height == 576)
  52         format = 4;
  53     else if (width == 1408 && height == 1152)
  54         format = 5;
  55     else
  56         format = 7;
  57     return format;
  58 }
  59
  60 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
  61 {
  62     int format;
  63
  64     align_put_bits(&s->pb);
  65
  66     /* Update the pointer to last GOB */
  67     s->ptr_lastgob = pbBufPtr(&s->pb);
  68     s->gob_number = 0;
  69
  70     put_bits(&s->pb, 22, 0x20); /* PSC */
  71     put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
  72                          s->frame_rate) & 0xff);
  73
  74     put_bits(&s->pb, 1, 1);     /* marker */
  75     put_bits(&s->pb, 1, 0);     /* h263 id */
  76     put_bits(&s->pb, 1, 0);     /* split screen off */
  77     put_bits(&s->pb, 1, 0);     /* camera  off */
  78     put_bits(&s->pb, 1, 0);     /* freeze picture release off */
  79
  80     format = h263_get_picture_format(s->width, s->height);
  81     if (!s->h263_plus) {
  82         /* H.263v1 */
  83         put_bits(&s->pb, 3, format);
  84         put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
  85         /* By now UMV IS DISABLED ON H.263v1, since the restrictions
  86         of H.263v1 UMV implies to check the predicted MV after
  87         calculation of the current MB to see if we're on the limits */
  88         put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
  89         put_bits(&s->pb, 1, 0); /* SAC: off */
  90         put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
  91         put_bits(&s->pb, 1, 0); /* not PB frame */
  92         put_bits(&s->pb, 5, s->qscale);
  93         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
  94     } else {
  95         /* H.263v2 */
  96         /* H.263 Plus PTYPE */
  97         put_bits(&s->pb, 3, 7);
  98         put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
  99         if (format == 7)
 100             put_bits(&s->pb,3,6); /* Custom Source Format */
 101         else
 102             put_bits(&s->pb, 3, format);
 103
 104         put_bits(&s->pb,1,0); /* Custom PCF: off */
 105         s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
 106         put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
 107         put_bits(&s->pb,1,0); /* SAC: off */
 108         put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
 109         put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
 110         put_bits(&s->pb,1,0); /* Deblocking Filter: off */
 111         put_bits(&s->pb,1,0); /* Slice Structured: off */
 112         put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
 113         put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
 114         put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
 115         put_bits(&s->pb,1,0); /* Modified Quantization: off */
 116         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 117         put_bits(&s->pb,3,0); /* Reserved */
 118
 119         put_bits(&s->pb, 3, s->pict_type == P_TYPE);
 120
 121         put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
 122         put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
 123         put_bits(&s->pb,1,0); /* Rounding Type */
 124         put_bits(&s->pb,2,0); /* Reserved */
 125         put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 126
 127         /* This should be here if PLUSPTYPE */
 128         put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
 129
 130                 if (format == 7) {
 131             /* Custom Picture Format (CPFMT) */
 132
 133             put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
 134             put_bits(&s->pb,9,(s->width >> 2) - 1);
 135             put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
 136             put_bits(&s->pb,9,(s->height >> 2));
 137         }
 138
 139         /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
 140         if (s->umvplus)
 141             put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
 142         put_bits(&s->pb, 5, s->qscale);
 143     }
 144
 145     put_bits(&s->pb, 1, 0);     /* no PEI */
 146 }
 147
 148 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
 149 {
 150     int pdif=0;
 151
 152     /* Check to see if we need to put a new GBSC */
 153     /* for RTP packetization                    */
 154     if (s->rtp_mode) {
 155         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
 156         if (pdif >= s->rtp_payload_size) {
 157             /* Bad luck, packet must be cut before */
 158             align_put_bits(&s->pb);
 159             flush_put_bits(&s->pb);
 160             /* Call the RTP callback to send the last GOB */
 161             if (s->rtp_callback) {
 162                 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
 163                 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
 164             }
 165             s->ptr_lastgob = pbBufPtr(&s->pb);
 166             put_bits(&s->pb, 17, 1); /* GBSC */
 167             s->gob_number = mb_line / s->gob_index;
 168             put_bits(&s->pb, 5, s->gob_number); /* GN */
 169             put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
 170             put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 171             //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
 172             return pdif;
 173        } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
 174            /* Cut the packet before we can't */
 175            align_put_bits(&s->pb);
 176            flush_put_bits(&s->pb);
 177            /* Call the RTP callback to send the last GOB */
 178            if (s->rtp_callback) {
 179                pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
 180                s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
 181            }
 182            s->ptr_lastgob = pbBufPtr(&s->pb);
 183            put_bits(&s->pb, 17, 1); /* GBSC */
 184            s->gob_number = mb_line / s->gob_index;
 185            put_bits(&s->pb, 5, s->gob_number); /* GN */
 186            put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
 187            put_bits(&s->pb, 5, s->qscale); /* GQUANT */
 188            //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
 189            return pdif;
 190        }
 191    }
 192    return 0;
 193 }
 194
 195 void h263_encode_mb(MpegEncContext * s,
 196                     DCTELEM block[6][64],
 197                     int motion_x, int motion_y)
 198 {
 199     int cbpc, cbpy, i, cbp, pred_x, pred_y;
 200
 201     //    printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 202    if (!s->mb_intra) {
 203            /* compute cbp */
 204            cbp = 0;
 205            for (i = 0; i < 6; i++) {
 206               if (s->block_last_index[i] >= 0)
 207                    cbp |= 1 << (5 - i);
 208            }
 209            if ((cbp | motion_x | motion_y) == 0) {
 210               /* skip macroblock */
 211               put_bits(&s->pb, 1, 1);
 212               return;
 213            }
 214            put_bits(&s->pb, 1, 0);      /* mb coded */
 215            cbpc = cbp & 3;
 216            put_bits(&s->pb,
 217                 inter_MCBPC_bits[cbpc],
 218                 inter_MCBPC_code[cbpc]);
 219            cbpy = cbp >> 2;
 220            cbpy ^= 0xf;
 221            put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 222
 223            /* motion vectors: 16x16 mode only now */
 224       h263_pred_motion(s, 0, &pred_x, &pred_y);
 225
 226       if (!s->umvplus) {
 227          h263_encode_motion(s, motion_x - pred_x);
 228          h263_encode_motion(s, motion_y - pred_y);
 229       }
 230       else {
 231          h263p_encode_umotion(s, motion_x - pred_x);
 232          h263p_encode_umotion(s, motion_y - pred_y);
 233          if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
 234             /* To prevent Start Code emulation */
 235             put_bits(&s->pb,1,1);
 236       }
 237    } else {
 238         /* compute cbp */
 239         cbp = 0;
 240         for (i = 0; i < 6; i++) {
 241             if (s->block_last_index[i] >= 1)
 242                 cbp |= 1 << (5 - i);
 243         }
 244
 245         cbpc = cbp & 3;
 246         if (s->pict_type == I_TYPE) {
 247             put_bits(&s->pb,
 248                      intra_MCBPC_bits[cbpc],
 249                      intra_MCBPC_code[cbpc]);
 250         } else {
 251             put_bits(&s->pb, 1, 0);     /* mb coded */
 252             put_bits(&s->pb,
 253                      inter_MCBPC_bits[cbpc + 4],
 254                      inter_MCBPC_code[cbpc + 4]);
 255         }
 256         if (s->h263_pred) {
 257             /* XXX: currently, we do not try to use ac prediction */
 258             put_bits(&s->pb, 1, 0);     /* no ac prediction */
 259         }
 260         cbpy = cbp >> 2;
 261         put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
 262     }
 263
 264     /* encode each block */
 265     if (s->h263_pred) {
 266         for (i = 0; i < 6; i++) {
 267             mpeg4_encode_block(s, block[i], i);
 268         }
 269     } else {
 270         for (i = 0; i < 6; i++) {
 271             h263_encode_block(s, block[i], i);
 272         }
 273     }
 274 }
 275
 276 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
 277 {
 278     int a, c, x, y, wrap, pred, scale;
 279     UINT16 *dc_val;
 280
 281     /* find prediction */
 282     if (n < 4) {
 283         x = 2 * s->mb_x + 1 + (n & 1);
 284         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 285         wrap = s->mb_width * 2 + 2;
 286         dc_val = s->dc_val[0];
 287         scale = s->y_dc_scale;
 288     } else {
 289         x = s->mb_x + 1;
 290         y = s->mb_y + 1;
 291         wrap = s->mb_width + 2;
 292         dc_val = s->dc_val[n - 4 + 1];
 293         scale = s->c_dc_scale;
 294     }
 295
 296     /* B C
 297      * A X
 298      */
 299     a = dc_val[(x - 1) + (y) * wrap];
 300     c = dc_val[(x) + (y - 1) * wrap];
 301
 302     if (s->ac_pred) {
 303         if (s->h263_aic_dir)
 304             pred = a;
 305         else
 306             pred = c;
 307     } else if (a != 1024 && c != 1024)
 308         pred = (a + c) >> 1;
 309     else if (a != 1024)
 310         pred = a;
 311     else
 312         pred = c;
 313
 314
 315     /* we assume pred is positive */
 316     pred = (pred) / scale;
 317
 318     /* prepare address for prediction update */
 319     *dc_val_ptr = &dc_val[(x) + (y) * wrap];
 320
 321     return pred;
 322 }
 323
 324 void h263_pred_ac(MpegEncContext * s, INT16 *block, int n)
 325 {
 326     int x, y, wrap, i;
 327     INT16 *ac_val, *ac_val1;
 328
 329     /* find prediction */
 330     if (n < 4) {
 331         x = 2 * s->mb_x + 1 + (n & 1);
 332         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 333         wrap = s->mb_width * 2 + 2;
 334         ac_val = s->ac_val[0][0];
 335     } else {
 336         x = s->mb_x + 1;
 337         y = s->mb_y + 1;
 338         wrap = s->mb_width + 2;
 339         ac_val = s->ac_val[n - 4 + 1][0];
 340     }
 341     ac_val += ((y) * wrap + (x)) * 16;
 342     ac_val1 = ac_val;
 343
 344     if (s->ac_pred) {
 345         if (s->h263_aic_dir) {
 346             /* left prediction */
 347             ac_val -= 16;
 348             for(i=1;i<8;i++) {
 349                 block[block_permute_op(i*8)] += ac_val[i];
 350             }
 351         } else {
 352             /* top prediction */
 353             ac_val -= 16 * wrap;
 354             for(i=1;i<8;i++) {
 355                 block[block_permute_op(i)] += ac_val[i + 8];
 356             }
 357         }
 358     }
 359     /* left copy */
 360     for(i=1;i<8;i++)
 361         ac_val1[i] = block[block_permute_op(i * 8)];
 362     /* top copy */
 363     for(i=1;i<8;i++)
 364         ac_val1[8 + i] = block[block_permute_op(i)];
 365 }
 366
 367 static inline int mid_pred(int a, int b, int c)
 368 {
 369     int vmin, vmax;
 370     vmax = vmin = a;
 371     if (b < vmin)
 372         vmin = b;
 373     else
 374         vmax = b;
 375
 376     if (c < vmin)
 377         vmin = c;
 378     else if (c > vmax)
 379         vmax = c;
 380
 381     return a + b + c - vmin - vmax;
 382 }
 383
 384 INT16 *h263_pred_motion(MpegEncContext * s, int block,
 385                         int *px, int *py)
 386 {
 387     int xy, y, wrap;
 388     INT16 *A, *B, *C, *mot_val;
 389
 390     wrap = 2 * s->mb_width + 2;
 391     y = xy = 2 * s->mb_y + 1 + ((block >> 1) & 1); // y
 392     xy *= wrap; // y * wrap
 393     xy += 2 * s->mb_x + 1 + (block & 1); // x + y * wrap
 394
 395     mot_val = s->motion_val[xy];
 396
 397     /* special case for first line */
 398     if (y == 1 || s->first_slice_line || s->first_gob_line) {
 399         A = s->motion_val[xy - 1];
 400         *px = A[0];
 401         *py = A[1];
 402     } else {
 403         switch(block) {
 404         default:
 405         case 0:
 406             A = s->motion_val[xy - 1];
 407             B = s->motion_val[xy - wrap];
 408             C = s->motion_val[xy + 2 - wrap];
 409             break;
 410         case 1:
 411         case 2:
 412             A = s->motion_val[xy - 1];
 413             B = s->motion_val[xy - wrap];
 414             C = s->motion_val[xy + 1 - wrap];
 415             break;
 416         case 3:
 417             A = s->motion_val[xy - 1];
 418             B = s->motion_val[xy - 1 - wrap];
 419             C = s->motion_val[xy - wrap];
 420             break;
 421         }
 422         *px = mid_pred(A[0], B[0], C[0]);
 423         *py = mid_pred(A[1], B[1], C[1]);
 424     }
 425     return mot_val;
 426 }
 427
 428
 429 static void h263_encode_motion(MpegEncContext * s, int val)
 430 {
 431     int range, l, m, bit_size, sign, code, bits;
 432
 433     if (val == 0) {
 434         /* zero vector */
 435         code = 0;
 436         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
 437     } else {
 438         bit_size = s->f_code - 1;
 439         range = 1 << bit_size;
 440         /* modulo encoding */
 441         l = range * 32;
 442         m = 2 * l;
 443         if (val < -l) {
 444             val += m;
 445         } else if (val >= l) {
 446             val -= m;
 447         }
 448
 449         if (val >= 0) {
 450             val--;
 451             code = (val >> bit_size) + 1;
 452             bits = val & (range - 1);
 453             sign = 0;
 454         } else {
 455             val = -val;
 456             val--;
 457             code = (val >> bit_size) + 1;
 458             bits = val & (range - 1);
 459             sign = 1;
 460         }
 461
 462         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
 463         if (bit_size > 0) {
 464             put_bits(&s->pb, bit_size, bits);
 465         }
 466     }
 467 }
 468
 469 /* Encode MV differences on H.263+ with Unrestricted MV mode */
 470 static void h263p_encode_umotion(MpegEncContext * s, int val)
 471 {
 472     short sval = 0;
 473     short i = 0;
 474     short n_bits = 0;
 475     short temp_val;
 476     int code = 0;
 477     int tcode;
 478
 479     if ( val == 0)
 480         put_bits(&s->pb, 1, 1);
 481     else if (val == 1)
 482         put_bits(&s->pb, 3, 0);
 483     else if (val == -1)
 484         put_bits(&s->pb, 3, 2);
 485     else {
 486
 487         sval = ((val < 0) ? (short)(-val):(short)val);
 488         temp_val = sval;
 489
 490         while (temp_val != 0) {
 491             temp_val = temp_val >> 1;
 492             n_bits++;
 493         }
 494
 495         i = n_bits - 1;
 496         while (i > 0) {
 497             tcode = (sval & (1 << (i-1))) >> (i-1);
 498             tcode = (tcode << 1) | 1;
 499             code = (code << 2) | tcode;
 500             i--;
 501         }
 502         code = ((code << 1) | (val < 0)) << 1;
 503         put_bits(&s->pb, (2*n_bits)+1, code);
 504         //printf("\nVal = %d\tCode = %d", sval, code);
 505     }
 506 }
 507
 508 void h263_encode_init_vlc(MpegEncContext *s)
 509 {
 510     static int done = 0;
 511
 512     if (!done) {
 513         done = 1;
 514         init_rl(&rl_inter);
 515         init_rl(&rl_intra);
 516     }
 517 }
 518
 519 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 520 {
 521     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
 522     int code;
 523     RLTable *rl = &rl_inter;
 524
 525     if (s->mb_intra) {
 526         /* DC coef */
 527             level = block[0];
 528         /* 255 cannot be represented, so we clamp */
 529         if (level > 254) {
 530             level = 254;
 531             block[0] = 254;
 532         }
 533         /* 0 cannot be represented also */
 534         else if (!level) {
 535             level = 1;
 536             block[0] = 1;
 537         }
 538             if (level == 128)
 539                 put_bits(&s->pb, 8, 0xff);
 540             else
 541                 put_bits(&s->pb, 8, level & 0xff);
 542             i = 1;
 543     } else {
 544             i = 0;
 545     }
 546
 547     /* AC coefs */
 548     last_index = s->block_last_index[n];
 549     last_non_zero = i - 1;
 550     for (; i <= last_index; i++) {
 551         j = zigzag_direct[i];
 552         level = block[j];
 553         if (level) {
 554             run = i - last_non_zero - 1;
 555             last = (i == last_index);
 556             sign = 0;
 557             slevel = level;
 558             if (level < 0) {
 559                 sign = 1;
 560                 level = -level;
 561             }
 562             code = get_rl_index(rl, last, run, level);
 563             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 564             if (code == rl->n) {
 565                 put_bits(&s->pb, 1, last);
 566                 put_bits(&s->pb, 6, run);
 567                 put_bits(&s->pb, 8, slevel & 0xff);
 568             } else {
 569                 put_bits(&s->pb, 1, sign);
 570             }
 571             last_non_zero = i;
 572         }
 573     }
 574 }
 575
 576 /***************************************************/
 577
 578 /* write mpeg4 VOP header */
 579 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 580 {
 581     align_put_bits(&s->pb);
 582
 583     put_bits(&s->pb, 16, 0);            /* vop header */
 584     put_bits(&s->pb, 16, 0x1B6);        /* vop header */
 585     put_bits(&s->pb, 2, s->pict_type - 1);      /* pict type: I = 0 , P = 1 */
 586     /* XXX: time base + 1 not always correct */
 587     put_bits(&s->pb, 1, 1);
 588     put_bits(&s->pb, 1, 0);
 589
 590     put_bits(&s->pb, 1, 1);     /* marker */
 591     put_bits(&s->pb, 4, 1);     /* XXX: correct time increment */
 592     put_bits(&s->pb, 1, 1);     /* marker */
 593     put_bits(&s->pb, 1, 1);     /* vop coded */
 594     if (s->pict_type == P_TYPE) {
 595         s->no_rounding = 0;
 596         put_bits(&s->pb, 1, s->no_rounding);    /* rounding type */
 597     }
 598     put_bits(&s->pb, 3, 0);     /* intra dc VLC threshold */
 599
 600     put_bits(&s->pb, 5, s->qscale);
 601
 602     if (s->pict_type != I_TYPE)
 603         put_bits(&s->pb, 3, s->f_code); /* fcode_for */
 604     //    printf("****frame %d\n", picture_number);
 605 }
 606
 607 void h263_dc_scale(MpegEncContext * s)
 608 {
 609     int quant;
 610
 611     quant = s->qscale;
 612     /* luminance */
 613     if (quant < 5)
 614         s->y_dc_scale = 8;
 615     else if (quant > 4 && quant < 9)
 616         s->y_dc_scale = (2 * quant);
 617     else if (quant > 8 && quant < 25)
 618         s->y_dc_scale = (quant + 8);
 619     else
 620         s->y_dc_scale = (2 * quant - 16);
 621     /* chrominance */
 622     if (quant < 5)
 623         s->c_dc_scale = 8;
 624     else if (quant > 4 && quant < 25)
 625         s->c_dc_scale = ((quant + 13) / 2);
 626     else
 627         s->c_dc_scale = (quant - 6);
 628 }
 629
 630 static int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
 631 {
 632     int a, b, c, xy, wrap, pred, scale;
 633     UINT16 *dc_val;
 634
 635     /* find prediction */
 636     if (n < 4) {
 637         wrap = s->mb_width * 2 + 2;
 638         xy = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 639         xy *= wrap;
 640         xy += 2 * s->mb_x + 1 + (n & 1);
 641         dc_val = s->dc_val[0];
 642         scale = s->y_dc_scale;
 643     } else {
 644         wrap = s->mb_width + 2;
 645         xy = s->mb_y + 1;
 646         xy *= wrap;
 647         xy += s->mb_x + 1;
 648         dc_val = s->dc_val[n - 4 + 1];
 649         scale = s->c_dc_scale;
 650     }
 651
 652     /* B C
 653      * A X
 654      */
 655     a = dc_val[xy - 1];
 656     b = dc_val[xy - 1 - wrap];
 657     c = dc_val[xy - wrap];
 658
 659     if (abs(a - b) < abs(b - c)) {
 660         pred = c;
 661         *dir_ptr = 1; /* top */
 662     } else {
 663         pred = a;
 664         *dir_ptr = 0; /* left */
 665     }
 666     /* we assume pred is positive */
 667     pred = (pred + (scale >> 1)) / scale;
 668
 669     /* prepare address for prediction update */
 670     *dc_val_ptr = &dc_val[xy];
 671
 672     return pred;
 673 }
 674
 675 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
 676                    int dir)
 677 {
 678     int x, y, wrap, i;
 679     INT16 *ac_val, *ac_val1;
 680
 681     /* find prediction */
 682     if (n < 4) {
 683         x = 2 * s->mb_x + 1 + (n & 1);
 684         y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
 685         wrap = s->mb_width * 2 + 2;
 686         ac_val = s->ac_val[0][0];
 687     } else {
 688         x = s->mb_x + 1;
 689         y = s->mb_y + 1;
 690         wrap = s->mb_width + 2;
 691         ac_val = s->ac_val[n - 4 + 1][0];
 692     }
 693     ac_val += ((y) * wrap + (x)) * 16;
 694     ac_val1 = ac_val;
 695     if (s->ac_pred) {
 696         if (dir == 0) {
 697             /* left prediction */
 698             ac_val -= 16;
 699             for(i=1;i<8;i++) {
 700                 block[block_permute_op(i*8)] += ac_val[i];
 701             }
 702         } else {
 703             /* top prediction */
 704             ac_val -= 16 * wrap;
 705             for(i=1;i<8;i++) {
 706                 block[block_permute_op(i)] += ac_val[i + 8];
 707             }
 708         }
 709     }
 710     /* left copy */
 711     for(i=1;i<8;i++)
 712         ac_val1[i] = block[block_permute_op(i * 8)];
 713     /* top copy */
 714     for(i=1;i<8;i++)
 715         ac_val1[8 + i] = block[block_permute_op(i)];
 716 }
 717
 718 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
 719 {
 720     int size, v, pred;
 721     UINT16 *dc_val;
 722
 723     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 724     if (n < 4) {
 725         *dc_val = level * s->y_dc_scale;
 726     } else {
 727         *dc_val = level * s->c_dc_scale;
 728     }
 729
 730     /* do the prediction */
 731     level -= pred;
 732     /* find number of bits */
 733     size = 0;
 734     v = abs(level);
 735     while (v) {
 736         v >>= 1;
 737         size++;
 738     }
 739
 740     if (n < 4) {
 741         /* luminance */
 742         put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
 743     } else {
 744         /* chrominance */
 745         put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
 746     }
 747
 748     /* encode remaining bits */
 749     if (size > 0) {
 750         if (level < 0)
 751             level = (-level) ^ ((1 << size) - 1);
 752         put_bits(&s->pb, size, level);
 753         if (size > 8)
 754             put_bits(&s->pb, 1, 1);
 755     }
 756 }
 757
 758 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 759 {
 760     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
 761     int code, dc_pred_dir;
 762     const RLTable *rl;
 763
 764     if (s->mb_intra) {
 765         /* mpeg4 based DC predictor */
 766         mpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
 767         i = 1;
 768         rl = &rl_intra;
 769     } else {
 770         i = 0;
 771         rl = &rl_inter;
 772     }
 773
 774     /* AC coefs */
 775     last_index = s->block_last_index[n];
 776     last_non_zero = i - 1;
 777     for (; i <= last_index; i++) {
 778         j = zigzag_direct[i];
 779         level = block[j];
 780         if (level) {
 781             run = i - last_non_zero - 1;
 782             last = (i == last_index);
 783             sign = 0;
 784             slevel = level;
 785             if (level < 0) {
 786                 sign = 1;
 787                 level = -level;
 788             }
 789             code = get_rl_index(rl, last, run, level);
 790             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 791             if (code == rl->n) {
 792                 int level1, run1;
 793                 level1 = level - rl->max_level[last][run];
 794                 if (level1 < 1)
 795                     goto esc2;
 796                 code = get_rl_index(rl, last, run, level1);
 797                 if (code == rl->n) {
 798                 esc2:
 799                     put_bits(&s->pb, 1, 1);
 800                     if (level > MAX_LEVEL)
 801                         goto esc3;
 802                     run1 = run - rl->max_run[last][level] - 1;
 803                     if (run1 < 0)
 804                         goto esc3;
 805                     code = get_rl_index(rl, last, run1, level);
 806                     if (code == rl->n) {
 807                     esc3:
 808                         /* third escape */
 809                         put_bits(&s->pb, 1, 1);
 810                         put_bits(&s->pb, 1, last);
 811                         put_bits(&s->pb, 6, run);
 812                         put_bits(&s->pb, 1, 1);
 813                         put_bits(&s->pb, 12, slevel & 0xfff);
 814                         put_bits(&s->pb, 1, 1);
 815                     } else {
 816                         /* second escape */
 817                         put_bits(&s->pb, 1, 0);
 818                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 819                         put_bits(&s->pb, 1, sign);
 820                     }
 821                 } else {
 822                     /* first escape */
 823                     put_bits(&s->pb, 1, 0);
 824                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 825                     put_bits(&s->pb, 1, sign);
 826                 }
 827             } else {
 828                 put_bits(&s->pb, 1, sign);
 829             }
 830             last_non_zero = i;
 831         }
 832     }
 833 }
 834
 835
 836
 837 /***********************************************/
 838 /* decoding */
 839
 840 static VLC intra_MCBPC_vlc;
 841 static VLC inter_MCBPC_vlc;
 842 static VLC cbpy_vlc;
 843 static VLC mv_vlc;
 844 static VLC dc_lum, dc_chrom;
 845
 846 void init_rl(RLTable *rl)
 847 {
 848     INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
 849     UINT8 index_run[MAX_RUN+1];
 850     int last, run, level, start, end, i;
 851
 852     /* compute max_level[], max_run[] and index_run[] */
 853     for(last=0;last<2;last++) {
 854         if (last == 0) {
 855             start = 0;
 856             end = rl->last;
 857         } else {
 858             start = rl->last;
 859             end = rl->n;
 860         }
 861
 862         memset(max_level, 0, MAX_RUN + 1);
 863         memset(max_run, 0, MAX_LEVEL + 1);
 864         memset(index_run, rl->n, MAX_RUN + 1);
 865         for(i=start;i<end;i++) {
 866             run = rl->table_run[i];
 867             level = rl->table_level[i];
 868             if (index_run[run] == rl->n)
 869                 index_run[run] = i;
 870             if (level > max_level[run])
 871                 max_level[run] = level;
 872             if (run > max_run[level])
 873                 max_run[level] = run;
 874         }
 875         rl->max_level[last] = malloc(MAX_RUN + 1);
 876         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
 877         rl->max_run[last] = malloc(MAX_LEVEL + 1);
 878         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
 879         rl->index_run[last] = malloc(MAX_RUN + 1);
 880         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
 881     }
 882 }
 883
 884 void init_vlc_rl(RLTable *rl)
 885 {
 886     init_vlc(&rl->vlc, 9, rl->n + 1,
 887              &rl->table_vlc[0][1], 4, 2,
 888              &rl->table_vlc[0][0], 4, 2);
 889 }
 890
 891 /* init vlcs */
 892
 893 /* XXX: find a better solution to handle static init */
 894 void h263_decode_init_vlc(MpegEncContext *s)
 895 {
 896     static int done = 0;
 897
 898     if (!done) {
 899         done = 1;
 900
 901         init_vlc(&intra_MCBPC_vlc, 6, 8,
 902                  intra_MCBPC_bits, 1, 1,
 903                  intra_MCBPC_code, 1, 1);
 904         init_vlc(&inter_MCBPC_vlc, 9, 25,
 905                  inter_MCBPC_bits, 1, 1,
 906                  inter_MCBPC_code, 1, 1);
 907         init_vlc(&cbpy_vlc, 6, 16,
 908                  &cbpy_tab[0][1], 2, 1,
 909                  &cbpy_tab[0][0], 2, 1);
 910         init_vlc(&mv_vlc, 9, 33,
 911                  &mvtab[0][1], 2, 1,
 912                  &mvtab[0][0], 2, 1);
 913         init_rl(&rl_inter);
 914         init_rl(&rl_intra);
 915         init_rl(&rl_intra_aic);
 916         init_vlc_rl(&rl_inter);
 917         init_vlc_rl(&rl_intra);
 918         init_vlc_rl(&rl_intra_aic);
 919         init_vlc(&dc_lum, 9, 13,
 920                  &DCtab_lum[0][1], 2, 1,
 921                  &DCtab_lum[0][0], 2, 1);
 922         init_vlc(&dc_chrom, 9, 13,
 923                  &DCtab_chrom[0][1], 2, 1,
 924                  &DCtab_chrom[0][0], 2, 1);
 925     }
 926 }
 927
 928 int h263_decode_gob_header(MpegEncContext *s)
 929 {
 930     unsigned int val, gfid;
 931
 932     /* Check for GOB Start Code */
 933     val = show_bits(&s->gb, 16);
 934     if (val == 0) {
 935         /* We have a GBSC probably with GSTUFF */
 936         skip_bits(&s->gb, 16); /* Drop the zeros */
 937         while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
 938 #ifdef DEBUG
 939         fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
 940 #endif
 941         s->gob_number = get_bits(&s->gb, 5); /* GN */
 942         gfid = get_bits(&s->gb, 2); /* GFID */
 943         s->qscale = get_bits(&s->gb, 5); /* GQUANT */
 944 #ifdef DEBUG
 945         fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
 946 #endif
 947         return 1;
 948     }
 949     return 0;
 950
 951 }
 952
 953 int h263_decode_mb(MpegEncContext *s,
 954                    DCTELEM block[6][64])
 955 {
 956     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
 957     INT16 *mot_val;
 958     static INT8 quant_tab[4] = { -1, -2, 1, 2 };
 959
 960     if (s->pict_type == P_TYPE) {
 961         if (get_bits1(&s->gb)) {
 962             /* skip mb */
 963             s->mb_intra = 0;
 964             for(i=0;i<6;i++)
 965                 s->block_last_index[i] = -1;
 966             s->mv_dir = MV_DIR_FORWARD;
 967             s->mv_type = MV_TYPE_16X16;
 968             s->mv[0][0][0] = 0;
 969             s->mv[0][0][1] = 0;
 970             s->mb_skiped = 1;
 971             return 0;
 972         }
 973         cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
 974         //fprintf(stderr, "\tCBPC: %d", cbpc);
 975         if (cbpc < 0)
 976             return -1;
 977         if (cbpc > 20)
 978             cbpc+=3;
 979         else if (cbpc == 20)
 980             fprintf(stderr, "Stuffing !");
 981
 982         dquant = cbpc & 8;
 983         s->mb_intra = ((cbpc & 4) != 0);
 984     } else {
 985         cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
 986         if (cbpc < 0)
 987             return -1;
 988         dquant = cbpc & 4;
 989         s->mb_intra = 1;
 990     }
 991
 992     if (!s->mb_intra) {
 993         cbpy = get_vlc(&s->gb, &cbpy_vlc);
 994         cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
 995         if (dquant) {
 996             s->qscale += quant_tab[get_bits(&s->gb, 2)];
 997             if (s->qscale < 1)
 998                 s->qscale = 1;
 999             else if (s->qscale > 31)
1000                 s->qscale = 31;
1001         }
1002         s->mv_dir = MV_DIR_FORWARD;
1003         if ((cbpc & 16) == 0) {
1004             /* 16x16 motion prediction */
1005             s->mv_type = MV_TYPE_16X16;
1006             h263_pred_motion(s, 0, &pred_x, &pred_y);
1007             if (s->umvplus_dec)
1008                mx = h263p_decode_umotion(s, pred_x);
1009             else
1010                mx = h263_decode_motion(s, pred_x);
1011             if (mx >= 0xffff)
1012                 return -1;
1013
1014             if (s->umvplus_dec)
1015                my = h263p_decode_umotion(s, pred_y);
1016             else
1017                my = h263_decode_motion(s, pred_y);
1018             if (my >= 0xffff)
1019                 return -1;
1020             s->mv[0][0][0] = mx;
1021             s->mv[0][0][1] = my;
1022             /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
1023             fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
1024             fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
1025             if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1026                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1027
1028         } else {
1029             s->mv_type = MV_TYPE_8X8;
1030             for(i=0;i<4;i++) {
1031                 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1032                 if (s->umvplus_dec)
1033                   mx = h263p_decode_umotion(s, pred_x);
1034                 else
1035                   mx = h263_decode_motion(s, pred_x);
1036                 if (mx >= 0xffff)
1037                     return -1;
1038
1039                 if (s->umvplus_dec)
1040                   my = h263p_decode_umotion(s, pred_y);
1041                 else
1042                   my = h263_decode_motion(s, pred_y);
1043                 if (my >= 0xffff)
1044                     return -1;
1045                 s->mv[0][i][0] = mx;
1046                 s->mv[0][i][1] = my;
1047                 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
1048                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1049                 mot_val[0] = mx;
1050                 mot_val[1] = my;
1051             }
1052         }
1053     } else {
1054         s->ac_pred = 0;
1055         if (s->h263_pred || s->h263_aic) {
1056             s->ac_pred = get_bits1(&s->gb);
1057             if (s->ac_pred && s->h263_aic)
1058                 s->h263_aic_dir = get_bits1(&s->gb);
1059         }
1060         cbpy = get_vlc(&s->gb, &cbpy_vlc);
1061         cbp = (cbpc & 3) | (cbpy << 2);
1062         if (dquant) {
1063             s->qscale += quant_tab[get_bits(&s->gb, 2)];
1064             if (s->qscale < 1)
1065                 s->qscale = 1;
1066             else if (s->qscale > 31)
1067                 s->qscale = 31;
1068         }
1069     }
1070
1071     /* decode each block */
1072     if (s->h263_pred) {
1073         for (i = 0; i < 6; i++) {
1074             if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1075                 return -1;
1076         }
1077     } else {
1078         for (i = 0; i < 6; i++) {
1079             if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1080                 return -1;
1081         }
1082     }
1083     return 0;
1084 }
1085
1086 static int h263_decode_motion(MpegEncContext * s, int pred)
1087 {
1088     int code, val, sign, shift, l, m;
1089
1090     code = get_vlc(&s->gb, &mv_vlc);
1091     if (code < 0)
1092         return 0xffff;
1093
1094     if (code == 0)
1095         return pred;
1096     sign = get_bits1(&s->gb);
1097     shift = s->f_code - 1;
1098     val = (code - 1) << shift;
1099     if (shift > 0)
1100         val |= get_bits(&s->gb, shift);
1101     val++;
1102     if (sign)
1103         val = -val;
1104     val += pred;
1105
1106     /* modulo decoding */
1107     if (!s->h263_long_vectors) {
1108         l = (1 << (s->f_code - 1)) * 32;
1109         m = 2 * l;
1110         if (val < -l) {
1111             val += m;
1112         } else if (val >= l) {
1113             val -= m;
1114         }
1115     } else {
1116         /* horrible h263 long vector mode */
1117         if (pred < -31 && val < -63)
1118             val += 64;
1119         if (pred > 32 && val > 63)
1120             val -= 64;
1121
1122     }
1123     return val;
1124 }
1125
1126 /* Decodes RVLC of H.263+ UMV */
1127 static int h263p_decode_umotion(MpegEncContext * s, int pred)
1128 {
1129    int code = 0, sign;
1130
1131    if (get_bits1(&s->gb)) /* Motion difference = 0 */
1132       return pred;
1133
1134    code = 2 + get_bits1(&s->gb);
1135
1136    while (get_bits1(&s->gb))
1137    {
1138       code <<= 1;
1139       code += get_bits1(&s->gb);
1140    }
1141    sign = code & 1;
1142    code >>= 1;
1143
1144    code = (sign) ? (pred - code) : (pred + code);
1145 #ifdef DEBUG
1146    fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
1147 #endif
1148    return code;
1149
1150 }
1151
1152 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1153                              int n, int coded)
1154 {
1155     int code, level, i, j, last, run;
1156     RLTable *rl = &rl_inter;
1157     UINT16 *dc_val;
1158     const UINT8 *scan_table;
1159
1160     scan_table = zigzag_direct;
1161     if (s->h263_aic) {
1162         rl = &rl_intra_aic;
1163         i = 0;
1164         if (s->ac_pred) {
1165             if (s->h263_aic_dir)
1166                 scan_table = ff_alternate_vertical_scan; /* left */
1167             else
1168                 scan_table = ff_alternate_horizontal_scan; /* top */
1169         }
1170     } else if (s->mb_intra) {
1171         /* DC coef */
1172         if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
1173             int component, diff;
1174             component = (n <= 3 ? 0 : n - 4 + 1);
1175             level = s->last_dc[component];
1176             if (s->rv10_first_dc_coded[component]) {
1177                 diff = rv_decode_dc(s, n);
1178                 if (diff == 0xffff)
1179                     return -1;
1180                 level += diff;
1181                 level = level & 0xff; /* handle wrap round */
1182                 s->last_dc[component] = level;
1183             } else {
1184                 s->rv10_first_dc_coded[component] = 1;
1185             }
1186         } else {
1187             level = get_bits(&s->gb, 8);
1188             if (level == 255)
1189                 level = 128;
1190         }
1191         block[0] = level;
1192         i = 1;
1193     } else {
1194         i = 0;
1195     }
1196     if (!coded) {
1197         if (s->mb_intra && s->h263_aic) {
1198             level = h263_pred_dc(s, n, &dc_val);
1199             if (level < 0)
1200                 level = 0;
1201             *dc_val = level * s->y_dc_scale;
1202             block[0] = level;
1203             h263_pred_ac(s, block, n);
1204             i = 64;
1205             //i = 1;
1206         }
1207         s->block_last_index[n] = i - 1;
1208         return 0;
1209     }
1210
1211     for(;;) {
1212         code = get_vlc(&s->gb, &rl->vlc);
1213         if (code < 0)
1214             return -1;
1215         if (code == rl->n) {
1216             /* escape */
1217             last = get_bits1(&s->gb);
1218             run = get_bits(&s->gb, 6);
1219             level = (INT8)get_bits(&s->gb, 8);
1220             if (s->h263_rv10 && level == -128) {
1221                 /* XXX: should patch encoder too */
1222                 level = get_bits(&s->gb, 12);
1223                 level = (level << 20) >> 20;
1224             }
1225         } else {
1226             run = rl->table_run[code];
1227             level = rl->table_level[code];
1228             last = code >= rl->last;
1229             if (get_bits1(&s->gb))
1230                 level = -level;
1231         }
1232         if (!i && s->h263_aic) {
1233             level += h263_pred_dc(s, n, &dc_val);
1234             if (level < 0)
1235                 level = 0;
1236             else if (level & 1)
1237                 level++;
1238             *dc_val = level * s->y_dc_scale;
1239
1240         }
1241         i += run;
1242         if (i >= 64)
1243             return -1;
1244         j = scan_table[i];
1245         block[j] = level;
1246         if (last)
1247             break;
1248         i++;
1249     }
1250
1251     if (s->h263_aic) {
1252         h263_pred_ac(s, block, n);
1253         i = 64;
1254     }
1255     s->block_last_index[n] = i;
1256     return 0;
1257 }
1258
1259 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1260 {
1261     int level, pred, code;
1262     UINT16 *dc_val;
1263
1264     if (n < 4)
1265         code = get_vlc(&s->gb, &dc_lum);
1266     else
1267         code = get_vlc(&s->gb, &dc_chrom);
1268     if (code < 0)
1269         return -1;
1270     if (code == 0) {
1271         level = 0;
1272     } else {
1273         level = get_bits(&s->gb, code);
1274         if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
1275             level = - (level ^ ((1 << code) - 1));
1276         if (code > 8)
1277             skip_bits1(&s->gb); /* marker */
1278     }
1279
1280     pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1281     level += pred;
1282     if (level < 0)
1283         level = 0;
1284     if (n < 4) {
1285         *dc_val = level * s->y_dc_scale;
1286     } else {
1287         *dc_val = level * s->c_dc_scale;
1288     }
1289     return level;
1290 }
1291
1292 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1293                               int n, int coded)
1294 {
1295     int code, level, i, j, last, run;
1296     int dc_pred_dir;
1297     RLTable *rl;
1298     const UINT8 *scan_table;
1299
1300     if (s->mb_intra) {
1301         /* DC coef */
1302         level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1303         if (level < 0)
1304             return -1;
1305         block[0] = level;
1306         i = 1;
1307         if (!coded)
1308             goto not_coded;
1309         rl = &rl_intra;
1310         if (s->ac_pred) {
1311             if (dc_pred_dir == 0)
1312                 scan_table = ff_alternate_vertical_scan; /* left */
1313             else
1314                 scan_table = ff_alternate_horizontal_scan; /* top */
1315         } else {
1316             scan_table = zigzag_direct;
1317         }
1318     } else {
1319         i = 0;
1320         if (!coded) {
1321             s->block_last_index[n] = i - 1;
1322             return 0;
1323         }
1324         rl = &rl_inter;
1325         scan_table = zigzag_direct;
1326     }
1327
1328     for(;;) {
1329         code = get_vlc(&s->gb, &rl->vlc);
1330         if (code < 0)
1331             return -1;
1332         if (code == rl->n) {
1333             /* escape */
1334             if (get_bits1(&s->gb) != 0) {
1335                 if (get_bits1(&s->gb) != 0) {
1336                     /* third escape */
1337                     last = get_bits1(&s->gb);
1338                     run = get_bits(&s->gb, 6);
1339                     get_bits1(&s->gb); /* marker */
1340                     level = get_bits(&s->gb, 12);
1341                     level = (level << 20) >> 20; /* sign extend */
1342                     skip_bits1(&s->gb); /* marker */
1343                 } else {
1344                     /* second escape */
1345                     code = get_vlc(&s->gb, &rl->vlc);
1346                     if (code < 0 || code >= rl->n)
1347                         return -1;
1348                     run = rl->table_run[code];
1349                     level = rl->table_level[code];
1350                     last = code >= rl->last;
1351                     run += rl->max_run[last][level] + 1;
1352                     if (get_bits1(&s->gb))
1353                         level = -level;
1354                 }
1355             } else {
1356                 /* first escape */
1357                 code = get_vlc(&s->gb, &rl->vlc);
1358                 if (code < 0 || code >= rl->n)
1359                     return -1;
1360                 run = rl->table_run[code];
1361                 level = rl->table_level[code];
1362                 last = code >= rl->last;
1363                 level += rl->max_level[last][run];
1364                 if (get_bits1(&s->gb))
1365                     level = -level;
1366             }
1367         } else {
1368             run = rl->table_run[code];
1369             level = rl->table_level[code];
1370             last = code >= rl->last;
1371             if (get_bits1(&s->gb))
1372                 level = -level;
1373         }
1374         i += run;
1375         if (i >= 64)
1376             return -1;
1377         j = scan_table[i];
1378         block[j] = level;
1379         i++;
1380         if (last)
1381             break;
1382     }
1383  not_coded:
1384     if (s->mb_intra) {
1385         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1386         if (s->ac_pred) {
1387             i = 64; /* XXX: not optimal */
1388         }
1389     }
1390     s->block_last_index[n] = i - 1;
1391     return 0;
1392 }
1393
1394 /* most is hardcoded. should extend to handle all h263 streams */
1395 int h263_decode_picture_header(MpegEncContext *s)
1396 {
1397     int format, width, height;
1398
1399     /* picture header */
1400     if (get_bits(&s->gb, 22) != 0x20)
1401         return -1;
1402     s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
1403
1404     if (get_bits1(&s->gb) != 1)
1405         return -1;      /* marker */
1406     if (get_bits1(&s->gb) != 0)
1407         return -1;      /* h263 id */
1408     skip_bits1(&s->gb); /* split screen off */
1409     skip_bits1(&s->gb); /* camera  off */
1410     skip_bits1(&s->gb); /* freeze picture release off */
1411
1412     /* Reset GOB number */
1413     s->gob_number = 0;
1414
1415     format = get_bits(&s->gb, 3);
1416
1417     if (format != 7 && format != 6) {
1418         s->h263_plus = 0;
1419         /* H.263v1 */
1420         width = h263_format[format][0];
1421         height = h263_format[format][1];
1422         if (!width)
1423             return -1;
1424
1425         s->width = width;
1426         s->height = height;
1427         s->pict_type = I_TYPE + get_bits1(&s->gb);
1428
1429         s->unrestricted_mv = get_bits1(&s->gb);
1430         s->h263_long_vectors = s->unrestricted_mv;
1431
1432         if (get_bits1(&s->gb) != 0)
1433             return -1;  /* SAC: off */
1434         if (get_bits1(&s->gb) != 0) {
1435             s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1436         }
1437
1438         if (get_bits1(&s->gb) != 0)
1439             return -1;  /* not PB frame */
1440
1441         s->qscale = get_bits(&s->gb, 5);
1442         skip_bits1(&s->gb);     /* Continuous Presence Multipoint mode: off */
1443     } else {
1444         int ufep;
1445
1446         /* H.263v2 */
1447         s->h263_plus = 1;
1448         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1449
1450         if (ufep == 1) {
1451             /* OPPTYPE */
1452             format = get_bits(&s->gb, 3);
1453             skip_bits(&s->gb,1); /* Custom PCF */
1454             s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1455             skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
1456             if (get_bits1(&s->gb) != 0) {
1457                 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
1458             }
1459             if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
1460                 s->h263_aic = 1;
1461             }
1462             skip_bits(&s->gb, 7);
1463             skip_bits(&s->gb, 3); /* Reserved */
1464         } else if (ufep != 0)
1465             return -1;
1466
1467         /* MPPTYPE */
1468         s->pict_type = get_bits(&s->gb, 3) + 1;
1469         if (s->pict_type != I_TYPE &&
1470             s->pict_type != P_TYPE)
1471             return -1;
1472         skip_bits(&s->gb, 7);
1473
1474         /* Get the picture dimensions */
1475         if (ufep) {
1476             if (format == 6) {
1477                 /* Custom Picture Format (CPFMT) */
1478                 skip_bits(&s->gb, 4); /* aspect ratio */
1479                 width = (get_bits(&s->gb, 9) + 1) * 4;
1480                 skip_bits1(&s->gb);
1481                 height = get_bits(&s->gb, 9) * 4;
1482 #ifdef DEBUG
1483                 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
1484 #endif
1485             }
1486             else {
1487                 width = h263_format[format][0];
1488                 height = h263_format[format][1];
1489             }
1490             if ((width == 0) || (height == 0))
1491                 return -1;
1492             s->width = width;
1493             s->height = height;
1494             if (s->umvplus_dec) {
1495                 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1496             }
1497         }
1498
1499         s->qscale = get_bits(&s->gb, 5);
1500     }
1501     /* PEI */
1502     while (get_bits1(&s->gb) != 0) {
1503         skip_bits(&s->gb, 8);
1504     }
1505     s->f_code = 1;
1506     return 0;
1507 }
1508
1509 /* decode mpeg4 VOP header */
1510 int mpeg4_decode_picture_header(MpegEncContext * s)
1511 {
1512     int time_incr, startcode, state, v;
1513
1514  redo:
1515     /* search next start code */
1516     align_get_bits(&s->gb);
1517     state = 0xff;
1518     for(;;) {
1519         v = get_bits(&s->gb, 8);
1520         if (state == 0x000001) {
1521             state = ((state << 8) | v) & 0xffffff;
1522             startcode = state;
1523             break;
1524         }
1525         state = ((state << 8) | v) & 0xffffff;
1526         /* XXX: really detect end of frame */
1527         if (state == 0)
1528             return -1;
1529     }
1530
1531     if (startcode == 0x120) {
1532         int time_increment_resolution, width, height, vo_ver_id;
1533
1534         /* vol header */
1535         skip_bits(&s->gb, 1); /* random access */
1536         skip_bits(&s->gb, 8); /* vo_type */
1537         if (get_bits1(&s->gb) != 0) { /* is_ol_id */
1538             vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
1539             skip_bits(&s->gb, 3); /* vo_priority */
1540         } else {
1541             vo_ver_id = 1;
1542         }
1543
1544         skip_bits(&s->gb, 4); /* aspect_ratio_info */
1545         skip_bits1(&s->gb); /* vol control parameter */
1546         s->shape = get_bits(&s->gb, 2); /* vol shape */
1547         skip_bits1(&s->gb);   /* marker */
1548
1549         time_increment_resolution = get_bits(&s->gb, 16);
1550         s->time_increment_bits = av_log2(time_increment_resolution - 1) + 1;
1551         if (s->time_increment_bits < 1)
1552             s->time_increment_bits = 1;
1553         skip_bits1(&s->gb);   /* marker */
1554
1555         if (get_bits1(&s->gb) != 0) {   /* fixed_vop_rate  */
1556             skip_bits(&s->gb, s->time_increment_bits);
1557         }
1558
1559         if (s->shape != 2) {
1560             if (s->shape == 0) {
1561                 skip_bits1(&s->gb);   /* marker */
1562                 width = get_bits(&s->gb, 13);
1563                 skip_bits1(&s->gb);   /* marker */
1564                 height = get_bits(&s->gb, 13);
1565                 skip_bits1(&s->gb);   /* marker */
1566             }
1567
1568             skip_bits1(&s->gb);   /* interlaced */
1569             skip_bits1(&s->gb);   /* OBMC */
1570             if (vo_ver_id == 1) {
1571                 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
1572             } else {
1573                 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
1574             }
1575             if (get_bits1(&s->gb) == 1) {   /* not_8_bit */
1576                 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
1577                 skip_bits(&s->gb, 4); /* bits_per_pixel */
1578             } else {
1579                 s->quant_precision = 5;
1580             }
1581
1582             skip_bits1(&s->gb);   /* vol_quant_type */
1583             skip_bits1(&s->gb);   /* vol_quarter_pixel */
1584             skip_bits1(&s->gb);   /* complexity_estimation_disabled */
1585             skip_bits1(&s->gb);   /* resync_marker_disabled */
1586             skip_bits1(&s->gb);   /* data_partioning_enabled */
1587             if (get_bits1(&s->gb) != 0) { /* scalability */
1588                 printf("bad scalability!!!\n");
1589                 return -1;
1590             }
1591         }
1592         goto redo;
1593     } else if (startcode != 0x1b6) {
1594         goto redo;
1595     }
1596
1597     s->pict_type = get_bits(&s->gb, 2) + 1;     /* pict type: I = 0 , P = 1 */
1598     if (s->pict_type != I_TYPE &&
1599         s->pict_type != P_TYPE)
1600         return -1;
1601
1602     /* XXX: parse time base */
1603     time_incr = 0;
1604     while (get_bits1(&s->gb) != 0)
1605         time_incr++;
1606
1607     skip_bits1(&s->gb);         /* marker */
1608     skip_bits(&s->gb, s->time_increment_bits);
1609     skip_bits1(&s->gb);         /* marker */
1610     /* vop coded */
1611     if (get_bits1(&s->gb) != 1)
1612         goto redo;
1613
1614     if (s->shape != 2 && s->pict_type == P_TYPE) {
1615         /* rounding type for motion estimation */
1616         s->no_rounding = get_bits1(&s->gb);
1617     } else {
1618         s->no_rounding = 0;
1619     }
1620
1621      if (s->shape != 0) {
1622          if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
1623              int width, height, hor_spat_ref, ver_spat_ref;
1624
1625              width = get_bits(&s->gb, 13);
1626              skip_bits1(&s->gb);   /* marker */
1627              height = get_bits(&s->gb, 13);
1628              skip_bits1(&s->gb);   /* marker */
1629              hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
1630              skip_bits1(&s->gb);   /* marker */
1631              ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
1632          }
1633          skip_bits1(&s->gb); /* change_CR_disable */
1634
1635          if (get_bits1(&s->gb) != 0) {
1636              skip_bits(&s->gb, 8); /* constant_alpha_value */
1637          }
1638      }
1639
1640      if (s->shape != 2) {
1641          skip_bits(&s->gb, 3); /* intra dc VLC threshold */
1642
1643          /* note: we do not use quant_precision to avoid problem if no
1644             MPEG4 vol header as it is found on some old opendivx
1645             movies */
1646          s->qscale = get_bits(&s->gb, 5);
1647
1648          if (s->pict_type != I_TYPE) {
1649              s->f_code = get_bits(&s->gb, 3);   /* fcode_for */
1650          }
1651          if (s->shape && (s->pict_type != I_TYPE)) {
1652              skip_bits1(&s->gb); // vop shape coding type
1653          }
1654      }
1655      return 0;
1656 }
1657
1658 /* don't understand why they choose a different header ! */
1659 int intel_h263_decode_picture_header(MpegEncContext *s)
1660 {
1661     int format;
1662
1663     /* picture header */
1664     if (get_bits(&s->gb, 22) != 0x20)
1665         return -1;
1666     skip_bits(&s->gb, 8); /* picture timestamp */
1667
1668     if (get_bits1(&s->gb) != 1)
1669         return -1;      /* marker */
1670     if (get_bits1(&s->gb) != 0)
1671         return -1;      /* h263 id */
1672     skip_bits1(&s->gb); /* split screen off */
1673     skip_bits1(&s->gb); /* camera  off */
1674     skip_bits1(&s->gb); /* freeze picture release off */
1675
1676     format = get_bits(&s->gb, 3);
1677     if (format != 7)
1678         return -1;
1679
1680     s->h263_plus = 0;
1681
1682     s->pict_type = I_TYPE + get_bits1(&s->gb);
1683
1684     s->unrestricted_mv = get_bits1(&s->gb);
1685     s->h263_long_vectors = s->unrestricted_mv;
1686
1687     if (get_bits1(&s->gb) != 0)
1688         return -1;      /* SAC: off */
1689     if (get_bits1(&s->gb) != 0)
1690         return -1;      /* advanced prediction mode: off */
1691     if (get_bits1(&s->gb) != 0)
1692         return -1;      /* not PB frame */
1693
1694     /* skip unknown header garbage */
1695     skip_bits(&s->gb, 41);
1696
1697     s->qscale = get_bits(&s->gb, 5);
1698     skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1699
1700     /* PEI */
1701     while (get_bits1(&s->gb) != 0) {
1702         skip_bits(&s->gb, 8);
1703     }
1704     s->f_code = 1;
1705     return 0;
1706 }
1707