PageRenderTime 110ms CodeModel.GetById 19ms app.highlight 80ms RepoModel.GetById 1ms app.codeStats 1ms

/libavcodec/ituh263dec.c

http://github.com/FFmpeg/FFmpeg
C | 1298 lines | 1031 code | 163 blank | 104 comment | 322 complexity | 7c41967e611fdf067f8204ea8f09b10b MD5 | raw file
   1/*
   2 * ITU H.263 bitstream decoder
   3 * Copyright (c) 2000,2001 Fabrice Bellard
   4 * H.263+ support.
   5 * Copyright (c) 2001 Juan J. Sierralta P
   6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   7 *
   8 * This file is part of FFmpeg.
   9 *
  10 * FFmpeg is free software; you can redistribute it and/or
  11 * modify it under the terms of the GNU Lesser General Public
  12 * License as published by the Free Software Foundation; either
  13 * version 2.1 of the License, or (at your option) any later version.
  14 *
  15 * FFmpeg 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 GNU
  18 * Lesser General Public License for more details.
  19 *
  20 * You should have received a copy of the GNU Lesser General Public
  21 * License along with FFmpeg; if not, write to the Free Software
  22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23 */
  24
  25/**
  26 * @file
  27 * H.263 decoder.
  28 */
  29
  30#define UNCHECKED_BITSTREAM_READER 1
  31#include <limits.h>
  32
  33#include "libavutil/attributes.h"
  34#include "libavutil/imgutils.h"
  35#include "libavutil/internal.h"
  36#include "libavutil/mathematics.h"
  37#include "avcodec.h"
  38#include "mpegvideo.h"
  39#include "h263.h"
  40#include "h263data.h"
  41#include "internal.h"
  42#include "mathops.h"
  43#include "mpegutils.h"
  44#include "unary.h"
  45#include "flv.h"
  46#include "rv10.h"
  47#include "mpeg4video.h"
  48#include "mpegvideodata.h"
  49
  50// The defines below define the number of bits that are read at once for
  51// reading vlc values. Changing these may improve speed and data cache needs
  52// be aware though that decreasing them may need the number of stages that is
  53// passed to get_vlc* to be increased.
  54#define MV_VLC_BITS 9
  55#define H263_MBTYPE_B_VLC_BITS 6
  56#define CBPC_B_VLC_BITS 3
  57
  58static const int h263_mb_type_b_map[15]= {
  59    MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
  60    MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP,
  61    MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT,
  62                      MB_TYPE_L0                                 | MB_TYPE_16x16,
  63                      MB_TYPE_L0   | MB_TYPE_CBP                 | MB_TYPE_16x16,
  64                      MB_TYPE_L0   | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
  65                      MB_TYPE_L1                                 | MB_TYPE_16x16,
  66                      MB_TYPE_L1   | MB_TYPE_CBP                 | MB_TYPE_16x16,
  67                      MB_TYPE_L1   | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
  68                      MB_TYPE_L0L1                               | MB_TYPE_16x16,
  69                      MB_TYPE_L0L1 | MB_TYPE_CBP                 | MB_TYPE_16x16,
  70                      MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
  71    0, //stuffing
  72    MB_TYPE_INTRA4x4                | MB_TYPE_CBP,
  73    MB_TYPE_INTRA4x4                | MB_TYPE_CBP | MB_TYPE_QUANT,
  74};
  75
  76void ff_h263_show_pict_info(MpegEncContext *s){
  77    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
  78    av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
  79         s->qscale, av_get_picture_type_char(s->pict_type),
  80         s->gb.size_in_bits, 1-s->no_rounding,
  81         s->obmc ? " AP" : "",
  82         s->umvplus ? " UMV" : "",
  83         s->h263_long_vectors ? " LONG" : "",
  84         s->h263_plus ? " +" : "",
  85         s->h263_aic ? " AIC" : "",
  86         s->alt_inter_vlc ? " AIV" : "",
  87         s->modified_quant ? " MQ" : "",
  88         s->loop_filter ? " LOOP" : "",
  89         s->h263_slice_structured ? " SS" : "",
  90         s->avctx->framerate.num, s->avctx->framerate.den
  91    );
  92    }
  93}
  94
  95/***********************************************/
  96/* decoding */
  97
  98VLC ff_h263_intra_MCBPC_vlc;
  99VLC ff_h263_inter_MCBPC_vlc;
 100VLC ff_h263_cbpy_vlc;
 101static VLC mv_vlc;
 102static VLC h263_mbtype_b_vlc;
 103static VLC cbpc_b_vlc;
 104
 105/* init vlcs */
 106
 107/* XXX: find a better solution to handle static init */
 108av_cold void ff_h263_decode_init_vlc(void)
 109{
 110    static volatile int done = 0;
 111
 112    if (!done) {
 113        INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
 114                 ff_h263_intra_MCBPC_bits, 1, 1,
 115                 ff_h263_intra_MCBPC_code, 1, 1, 72);
 116        INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
 117                 ff_h263_inter_MCBPC_bits, 1, 1,
 118                 ff_h263_inter_MCBPC_code, 1, 1, 198);
 119        INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16,
 120                 &ff_h263_cbpy_tab[0][1], 2, 1,
 121                 &ff_h263_cbpy_tab[0][0], 2, 1, 64);
 122        INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,
 123                 &ff_mvtab[0][1], 2, 1,
 124                 &ff_mvtab[0][0], 2, 1, 538);
 125        ff_rl_init(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
 126        ff_rl_init(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);
 127        INIT_VLC_RL(ff_h263_rl_inter, 554);
 128        INIT_VLC_RL(ff_rl_intra_aic, 554);
 129        INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
 130                 &ff_h263_mbtype_b_tab[0][1], 2, 1,
 131                 &ff_h263_mbtype_b_tab[0][0], 2, 1, 80);
 132        INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
 133                 &ff_cbpc_b_tab[0][1], 2, 1,
 134                 &ff_cbpc_b_tab[0][0], 2, 1, 8);
 135        done = 1;
 136    }
 137}
 138
 139int ff_h263_decode_mba(MpegEncContext *s)
 140{
 141    int i, mb_pos;
 142
 143    for (i = 0; i < 6; i++)
 144        if (s->mb_num - 1 <= ff_mba_max[i])
 145            break;
 146    mb_pos  = get_bits(&s->gb, ff_mba_length[i]);
 147    s->mb_x = mb_pos % s->mb_width;
 148    s->mb_y = mb_pos / s->mb_width;
 149
 150    return mb_pos;
 151}
 152
 153/**
 154 * Decode the group of blocks header or slice header.
 155 * @return <0 if an error occurred
 156 */
 157static int h263_decode_gob_header(MpegEncContext *s)
 158{
 159    unsigned int val, gob_number;
 160    int left;
 161
 162    /* Check for GOB Start Code */
 163    val = show_bits(&s->gb, 16);
 164    if(val)
 165        return -1;
 166
 167        /* We have a GBSC probably with GSTUFF */
 168    skip_bits(&s->gb, 16); /* Drop the zeros */
 169    left= get_bits_left(&s->gb);
 170    left = FFMIN(left, 32);
 171    //MN: we must check the bits left or we might end in an infinite loop (or segfault)
 172    for(;left>13; left--){
 173        if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
 174    }
 175    if(left<=13)
 176        return -1;
 177
 178    if(s->h263_slice_structured){
 179        if(check_marker(s->avctx, &s->gb, "before MBA")==0)
 180            return -1;
 181
 182        ff_h263_decode_mba(s);
 183
 184        if(s->mb_num > 1583)
 185            if(check_marker(s->avctx, &s->gb, "after MBA")==0)
 186                return -1;
 187
 188        s->qscale = get_bits(&s->gb, 5); /* SQUANT */
 189        if(check_marker(s->avctx, &s->gb, "after SQUANT")==0)
 190            return -1;
 191        skip_bits(&s->gb, 2); /* GFID */
 192    }else{
 193        gob_number = get_bits(&s->gb, 5); /* GN */
 194        s->mb_x= 0;
 195        s->mb_y= s->gob_index* gob_number;
 196        skip_bits(&s->gb, 2); /* GFID */
 197        s->qscale = get_bits(&s->gb, 5); /* GQUANT */
 198    }
 199
 200    if(s->mb_y >= s->mb_height)
 201        return -1;
 202
 203    if(s->qscale==0)
 204        return -1;
 205
 206    return 0;
 207}
 208
 209/**
 210 * Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).
 211 * @return bit position of the resync_marker, or <0 if none was found
 212 */
 213int ff_h263_resync(MpegEncContext *s){
 214    int left, pos, ret;
 215
 216    /* In MPEG-4 studio mode look for a new slice startcode
 217     * and decode slice header */
 218    if(s->codec_id==AV_CODEC_ID_MPEG4 && s->studio_profile) {
 219        align_get_bits(&s->gb);
 220
 221        while (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) != SLICE_START_CODE) {
 222            get_bits(&s->gb, 8);
 223        }
 224
 225        if (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) == SLICE_START_CODE)
 226            return get_bits_count(&s->gb);
 227        else
 228            return -1;
 229    }
 230
 231    if(s->codec_id==AV_CODEC_ID_MPEG4){
 232        skip_bits1(&s->gb);
 233        align_get_bits(&s->gb);
 234    }
 235
 236    if(show_bits(&s->gb, 16)==0){
 237        pos= get_bits_count(&s->gb);
 238        if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)
 239            ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data);
 240        else
 241            ret= h263_decode_gob_header(s);
 242        if(ret>=0)
 243            return pos;
 244    }
 245    //OK, it's not where it is supposed to be ...
 246    s->gb= s->last_resync_gb;
 247    align_get_bits(&s->gb);
 248    left= get_bits_left(&s->gb);
 249
 250    for(;left>16+1+5+5; left-=8){
 251        if(show_bits(&s->gb, 16)==0){
 252            GetBitContext bak= s->gb;
 253
 254            pos= get_bits_count(&s->gb);
 255            if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)
 256                ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data);
 257            else
 258                ret= h263_decode_gob_header(s);
 259            if(ret>=0)
 260                return pos;
 261
 262            s->gb= bak;
 263        }
 264        skip_bits(&s->gb, 8);
 265    }
 266
 267    return -1;
 268}
 269
 270int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code)
 271{
 272    int code, val, sign, shift;
 273    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
 274
 275    if (code == 0)
 276        return pred;
 277    if (code < 0)
 278        return 0xffff;
 279
 280    sign = get_bits1(&s->gb);
 281    shift = f_code - 1;
 282    val = code;
 283    if (shift) {
 284        val = (val - 1) << shift;
 285        val |= get_bits(&s->gb, shift);
 286        val++;
 287    }
 288    if (sign)
 289        val = -val;
 290    val += pred;
 291
 292    /* modulo decoding */
 293    if (!s->h263_long_vectors) {
 294        val = sign_extend(val, 5 + f_code);
 295    } else {
 296        /* horrible H.263 long vector mode */
 297        if (pred < -31 && val < -63)
 298            val += 64;
 299        if (pred > 32 && val > 63)
 300            val -= 64;
 301
 302    }
 303    return val;
 304}
 305
 306
 307/* Decode RVLC of H.263+ UMV */
 308static int h263p_decode_umotion(MpegEncContext * s, int pred)
 309{
 310   int code = 0, sign;
 311
 312   if (get_bits1(&s->gb)) /* Motion difference = 0 */
 313      return pred;
 314
 315   code = 2 + get_bits1(&s->gb);
 316
 317   while (get_bits1(&s->gb))
 318   {
 319      code <<= 1;
 320      code += get_bits1(&s->gb);
 321      if (code >= 32768) {
 322          avpriv_request_sample(s->avctx, "Huge DMV");
 323          return 0xffff;
 324      }
 325   }
 326   sign = code & 1;
 327   code >>= 1;
 328
 329   code = (sign) ? (pred - code) : (pred + code);
 330   ff_tlog(s->avctx,"H.263+ UMV Motion = %d\n", code);
 331   return code;
 332
 333}
 334
 335/**
 336 * read the next MVs for OBMC. yes this is an ugly hack, feel free to send a patch :)
 337 */
 338static void preview_obmc(MpegEncContext *s){
 339    GetBitContext gb= s->gb;
 340
 341    int cbpc, i, pred_x, pred_y, mx, my;
 342    int16_t *mot_val;
 343    const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
 344    const int stride= s->b8_stride*2;
 345
 346    for(i=0; i<4; i++)
 347        s->block_index[i]+= 2;
 348    for(i=4; i<6; i++)
 349        s->block_index[i]+= 1;
 350    s->mb_x++;
 351
 352    av_assert2(s->pict_type == AV_PICTURE_TYPE_P);
 353
 354    do{
 355        if (get_bits1(&s->gb)) {
 356            /* skip mb */
 357            mot_val = s->current_picture.motion_val[0][s->block_index[0]];
 358            mot_val[0       ]= mot_val[2       ]=
 359            mot_val[0+stride]= mot_val[2+stride]= 0;
 360            mot_val[1       ]= mot_val[3       ]=
 361            mot_val[1+stride]= mot_val[3+stride]= 0;
 362
 363            s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
 364            goto end;
 365        }
 366        cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
 367    }while(cbpc == 20);
 368
 369    if(cbpc & 4){
 370        s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
 371    }else{
 372        get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 373        if (cbpc & 8) {
 374            if(s->modified_quant){
 375                if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
 376                else                  skip_bits(&s->gb, 5);
 377            }else
 378                skip_bits(&s->gb, 2);
 379        }
 380
 381        if ((cbpc & 16) == 0) {
 382                s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
 383                /* 16x16 motion prediction */
 384                mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 385                if (s->umvplus)
 386                    mx = h263p_decode_umotion(s, pred_x);
 387                else
 388                    mx = ff_h263_decode_motion(s, pred_x, 1);
 389
 390                if (s->umvplus)
 391                    my = h263p_decode_umotion(s, pred_y);
 392                else
 393                    my = ff_h263_decode_motion(s, pred_y, 1);
 394
 395                mot_val[0       ]= mot_val[2       ]=
 396                mot_val[0+stride]= mot_val[2+stride]= mx;
 397                mot_val[1       ]= mot_val[3       ]=
 398                mot_val[1+stride]= mot_val[3+stride]= my;
 399        } else {
 400            s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
 401            for(i=0;i<4;i++) {
 402                mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 403                if (s->umvplus)
 404                    mx = h263p_decode_umotion(s, pred_x);
 405                else
 406                    mx = ff_h263_decode_motion(s, pred_x, 1);
 407
 408                if (s->umvplus)
 409                    my = h263p_decode_umotion(s, pred_y);
 410                else
 411                    my = ff_h263_decode_motion(s, pred_y, 1);
 412                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
 413                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
 414                mot_val[0] = mx;
 415                mot_val[1] = my;
 416            }
 417        }
 418    }
 419end:
 420
 421    for(i=0; i<4; i++)
 422        s->block_index[i]-= 2;
 423    for(i=4; i<6; i++)
 424        s->block_index[i]-= 1;
 425    s->mb_x--;
 426
 427    s->gb= gb;
 428}
 429
 430static void h263_decode_dquant(MpegEncContext *s){
 431    static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 432
 433    if(s->modified_quant){
 434        if(get_bits1(&s->gb))
 435            s->qscale= ff_modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
 436        else
 437            s->qscale= get_bits(&s->gb, 5);
 438    }else
 439        s->qscale += quant_tab[get_bits(&s->gb, 2)];
 440    ff_set_qscale(s, s->qscale);
 441}
 442
 443static int h263_decode_block(MpegEncContext * s, int16_t * block,
 444                             int n, int coded)
 445{
 446    int level, i, j, run;
 447    RLTable *rl = &ff_h263_rl_inter;
 448    const uint8_t *scan_table;
 449    GetBitContext gb= s->gb;
 450
 451    scan_table = s->intra_scantable.permutated;
 452    if (s->h263_aic && s->mb_intra) {
 453        rl = &ff_rl_intra_aic;
 454        i = 0;
 455        if (s->ac_pred) {
 456            if (s->h263_aic_dir)
 457                scan_table = s->intra_v_scantable.permutated; /* left */
 458            else
 459                scan_table = s->intra_h_scantable.permutated; /* top */
 460        }
 461    } else if (s->mb_intra) {
 462        /* DC coef */
 463        if (CONFIG_RV10_DECODER && s->codec_id == AV_CODEC_ID_RV10) {
 464          if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) {
 465            int component, diff;
 466            component = (n <= 3 ? 0 : n - 4 + 1);
 467            level = s->last_dc[component];
 468            if (s->rv10_first_dc_coded[component]) {
 469                diff = ff_rv_decode_dc(s, n);
 470                if (diff == 0xffff)
 471                    return -1;
 472                level += diff;
 473                level = level & 0xff; /* handle wrap round */
 474                s->last_dc[component] = level;
 475            } else {
 476                s->rv10_first_dc_coded[component] = 1;
 477            }
 478          } else {
 479                level = get_bits(&s->gb, 8);
 480                if (level == 255)
 481                    level = 128;
 482          }
 483        }else{
 484            level = get_bits(&s->gb, 8);
 485            if((level&0x7F) == 0){
 486                av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
 487                if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
 488                    return -1;
 489            }
 490            if (level == 255)
 491                level = 128;
 492        }
 493        block[0] = level;
 494        i = 1;
 495    } else {
 496        i = 0;
 497    }
 498    if (!coded) {
 499        if (s->mb_intra && s->h263_aic)
 500            goto not_coded;
 501        s->block_last_index[n] = i - 1;
 502        return 0;
 503    }
 504retry:
 505    {
 506    OPEN_READER(re, &s->gb);
 507    i--; // offset by -1 to allow direct indexing of scan_table
 508    for(;;) {
 509        UPDATE_CACHE(re, &s->gb);
 510        GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
 511        if (run == 66) {
 512            if (level){
 513                CLOSE_READER(re, &s->gb);
 514                av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
 515                return -1;
 516            }
 517            /* escape */
 518            if (CONFIG_FLV_DECODER && s->h263_flv > 1) {
 519                int is11 = SHOW_UBITS(re, &s->gb, 1);
 520                SKIP_CACHE(re, &s->gb, 1);
 521                run = SHOW_UBITS(re, &s->gb, 7) + 1;
 522                if (is11) {
 523                    SKIP_COUNTER(re, &s->gb, 1 + 7);
 524                    UPDATE_CACHE(re, &s->gb);
 525                    level = SHOW_SBITS(re, &s->gb, 11);
 526                    SKIP_COUNTER(re, &s->gb, 11);
 527                } else {
 528                    SKIP_CACHE(re, &s->gb, 7);
 529                    level = SHOW_SBITS(re, &s->gb, 7);
 530                    SKIP_COUNTER(re, &s->gb, 1 + 7 + 7);
 531                }
 532            } else {
 533                run = SHOW_UBITS(re, &s->gb, 7) + 1;
 534                SKIP_CACHE(re, &s->gb, 7);
 535                level = (int8_t)SHOW_UBITS(re, &s->gb, 8);
 536                SKIP_COUNTER(re, &s->gb, 7 + 8);
 537                if(level == -128){
 538                    UPDATE_CACHE(re, &s->gb);
 539                    if (s->codec_id == AV_CODEC_ID_RV10) {
 540                        /* XXX: should patch encoder too */
 541                        level = SHOW_SBITS(re, &s->gb, 12);
 542                        SKIP_COUNTER(re, &s->gb, 12);
 543                    }else{
 544                        level = SHOW_UBITS(re, &s->gb, 5);
 545                        SKIP_CACHE(re, &s->gb, 5);
 546                        level |= SHOW_SBITS(re, &s->gb, 6) * (1<<5);
 547                        SKIP_COUNTER(re, &s->gb, 5 + 6);
 548                    }
 549                }
 550            }
 551        } else {
 552            if (SHOW_UBITS(re, &s->gb, 1))
 553                level = -level;
 554            SKIP_COUNTER(re, &s->gb, 1);
 555        }
 556        i += run;
 557        if (i >= 64){
 558            CLOSE_READER(re, &s->gb);
 559            // redo update without last flag, revert -1 offset
 560            i = i - run + ((run-1)&63) + 1;
 561            if (i < 64) {
 562                // only last marker, no overrun
 563                block[scan_table[i]] = level;
 564                break;
 565            }
 566            if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){
 567                //Looks like a hack but no, it's the way it is supposed to work ...
 568                rl = &ff_rl_intra_aic;
 569                i = 0;
 570                s->gb= gb;
 571                s->bdsp.clear_block(block);
 572                goto retry;
 573            }
 574            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
 575            return -1;
 576        }
 577        j = scan_table[i];
 578        block[j] = level;
 579    }
 580    }
 581not_coded:
 582    if (s->mb_intra && s->h263_aic) {
 583        ff_h263_pred_acdc(s, block, n);
 584        i = 63;
 585    }
 586    s->block_last_index[n] = i;
 587    return 0;
 588}
 589
 590static int h263_skip_b_part(MpegEncContext *s, int cbp)
 591{
 592    LOCAL_ALIGNED_32(int16_t, dblock, [64]);
 593    int i, mbi;
 594    int bli[6];
 595
 596    /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
 597     * but real value should be restored in order to be used later (in OBMC condition)
 598     */
 599    mbi = s->mb_intra;
 600    memcpy(bli, s->block_last_index, sizeof(bli));
 601    s->mb_intra = 0;
 602    for (i = 0; i < 6; i++) {
 603        if (h263_decode_block(s, dblock, i, cbp&32) < 0)
 604            return -1;
 605        cbp+=cbp;
 606    }
 607    s->mb_intra = mbi;
 608    memcpy(s->block_last_index, bli, sizeof(bli));
 609    return 0;
 610}
 611
 612static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
 613{
 614    int c, mv = 1;
 615
 616    if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame
 617        c = get_bits1(gb);
 618        if (pb_frame == 2 && c)
 619            mv = !get_bits1(gb);
 620    } else { // h.263 Annex M improved PB-frame
 621        mv = get_unary(gb, 0, 4) + 1;
 622        c = mv & 1;
 623        mv = !!(mv & 2);
 624    }
 625    if(c)
 626        *cbpb = get_bits(gb, 6);
 627    return mv;
 628}
 629
 630#define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
 631#define tab_bias (tab_size / 2)
 632static inline void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)
 633{
 634    int xy           = s->block_index[i];
 635    uint16_t time_pp = s->pp_time;
 636    uint16_t time_pb = s->pb_time;
 637    int p_mx, p_my;
 638
 639    p_mx = p->motion_val[0][xy][0];
 640    if ((unsigned)(p_mx + tab_bias) < tab_size) {
 641        s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias];
 642        s->mv[1][i][0] = s->direct_scale_mv[1][p_mx + tab_bias];
 643    } else {
 644        s->mv[0][i][0] = p_mx * time_pb / time_pp;
 645        s->mv[1][i][0] = p_mx * (time_pb - time_pp) / time_pp;
 646    }
 647    p_my = p->motion_val[0][xy][1];
 648    if ((unsigned)(p_my + tab_bias) < tab_size) {
 649        s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias];
 650        s->mv[1][i][1] = s->direct_scale_mv[1][p_my + tab_bias];
 651    } else {
 652        s->mv[0][i][1] = p_my * time_pb / time_pp;
 653        s->mv[1][i][1] = p_my * (time_pb - time_pp) / time_pp;
 654    }
 655}
 656
 657/**
 658 * @return the mb_type
 659 */
 660static int set_direct_mv(MpegEncContext *s)
 661{
 662    const int mb_index = s->mb_x + s->mb_y * s->mb_stride;
 663    Picture *p = &s->next_picture;
 664    int colocated_mb_type = p->mb_type[mb_index];
 665    int i;
 666
 667    if (s->codec_tag == AV_RL32("U263") && p->f->pict_type == AV_PICTURE_TYPE_I) {
 668        p = &s->last_picture;
 669        colocated_mb_type = p->mb_type[mb_index];
 670    }
 671
 672    if (IS_8X8(colocated_mb_type)) {
 673        s->mv_type = MV_TYPE_8X8;
 674        for (i = 0; i < 4; i++)
 675            set_one_direct_mv(s, p, i);
 676        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
 677    } else {
 678        set_one_direct_mv(s, p, 0);
 679        s->mv[0][1][0] =
 680        s->mv[0][2][0] =
 681        s->mv[0][3][0] = s->mv[0][0][0];
 682        s->mv[0][1][1] =
 683        s->mv[0][2][1] =
 684        s->mv[0][3][1] = s->mv[0][0][1];
 685        s->mv[1][1][0] =
 686        s->mv[1][2][0] =
 687        s->mv[1][3][0] = s->mv[1][0][0];
 688        s->mv[1][1][1] =
 689        s->mv[1][2][1] =
 690        s->mv[1][3][1] = s->mv[1][0][1];
 691        s->mv_type = MV_TYPE_8X8;
 692        // Note see prev line
 693        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1;
 694    }
 695}
 696
 697int ff_h263_decode_mb(MpegEncContext *s,
 698                      int16_t block[6][64])
 699{
 700    int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
 701    int16_t *mot_val;
 702    const int xy= s->mb_x + s->mb_y * s->mb_stride;
 703    int cbpb = 0, pb_mv_count = 0;
 704
 705    av_assert2(!s->h263_pred);
 706
 707    if (s->pict_type == AV_PICTURE_TYPE_P) {
 708        do{
 709            if (get_bits1(&s->gb)) {
 710                /* skip mb */
 711                s->mb_intra = 0;
 712                for(i=0;i<6;i++)
 713                    s->block_last_index[i] = -1;
 714                s->mv_dir = MV_DIR_FORWARD;
 715                s->mv_type = MV_TYPE_16X16;
 716                s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
 717                s->mv[0][0][0] = 0;
 718                s->mv[0][0][1] = 0;
 719                s->mb_skipped = !(s->obmc | s->loop_filter);
 720                goto end;
 721            }
 722            cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
 723            if (cbpc < 0){
 724                av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
 725                return SLICE_ERROR;
 726            }
 727        }while(cbpc == 20);
 728
 729        s->bdsp.clear_blocks(s->block[0]);
 730
 731        dquant = cbpc & 8;
 732        s->mb_intra = ((cbpc & 4) != 0);
 733        if (s->mb_intra) goto intra;
 734
 735        if(s->pb_frame && get_bits1(&s->gb))
 736            pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
 737        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 738
 739        if (cbpy < 0) {
 740            av_log(s->avctx, AV_LOG_ERROR, "cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
 741            return SLICE_ERROR;
 742        }
 743
 744        if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
 745            cbpy ^= 0xF;
 746
 747        cbp = (cbpc & 3) | (cbpy << 2);
 748        if (dquant) {
 749            h263_decode_dquant(s);
 750        }
 751
 752        s->mv_dir = MV_DIR_FORWARD;
 753        if ((cbpc & 16) == 0) {
 754            s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
 755            /* 16x16 motion prediction */
 756            s->mv_type = MV_TYPE_16X16;
 757            ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 758            if (s->umvplus)
 759               mx = h263p_decode_umotion(s, pred_x);
 760            else
 761               mx = ff_h263_decode_motion(s, pred_x, 1);
 762
 763            if (mx >= 0xffff)
 764                return SLICE_ERROR;
 765
 766            if (s->umvplus)
 767               my = h263p_decode_umotion(s, pred_y);
 768            else
 769               my = ff_h263_decode_motion(s, pred_y, 1);
 770
 771            if (my >= 0xffff)
 772                return SLICE_ERROR;
 773            s->mv[0][0][0] = mx;
 774            s->mv[0][0][1] = my;
 775
 776            if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
 777               skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
 778        } else {
 779            s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
 780            s->mv_type = MV_TYPE_8X8;
 781            for(i=0;i<4;i++) {
 782                mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
 783                if (s->umvplus)
 784                    mx = h263p_decode_umotion(s, pred_x);
 785                else
 786                    mx = ff_h263_decode_motion(s, pred_x, 1);
 787                if (mx >= 0xffff)
 788                    return SLICE_ERROR;
 789
 790                if (s->umvplus)
 791                    my = h263p_decode_umotion(s, pred_y);
 792                else
 793                    my = ff_h263_decode_motion(s, pred_y, 1);
 794                if (my >= 0xffff)
 795                    return SLICE_ERROR;
 796                s->mv[0][i][0] = mx;
 797                s->mv[0][i][1] = my;
 798                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
 799                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
 800                mot_val[0] = mx;
 801                mot_val[1] = my;
 802            }
 803        }
 804    } else if(s->pict_type==AV_PICTURE_TYPE_B) {
 805        int mb_type;
 806        const int stride= s->b8_stride;
 807        int16_t *mot_val0 = s->current_picture.motion_val[0][2 * (s->mb_x + s->mb_y * stride)];
 808        int16_t *mot_val1 = s->current_picture.motion_val[1][2 * (s->mb_x + s->mb_y * stride)];
 809//        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
 810
 811        //FIXME ugly
 812        mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
 813        mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
 814        mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
 815        mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
 816
 817        do{
 818            mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
 819            if (mb_type < 0){
 820                av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
 821                return SLICE_ERROR;
 822            }
 823
 824            mb_type= h263_mb_type_b_map[ mb_type ];
 825        }while(!mb_type);
 826
 827        s->mb_intra = IS_INTRA(mb_type);
 828        if(HAS_CBP(mb_type)){
 829            s->bdsp.clear_blocks(s->block[0]);
 830            cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
 831            if(s->mb_intra){
 832                dquant = IS_QUANT(mb_type);
 833                goto intra;
 834            }
 835
 836            cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 837
 838            if (cbpy < 0){
 839                av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
 840                return SLICE_ERROR;
 841            }
 842
 843            if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
 844                cbpy ^= 0xF;
 845
 846            cbp = (cbpc & 3) | (cbpy << 2);
 847        }else
 848            cbp=0;
 849
 850        av_assert2(!s->mb_intra);
 851
 852        if(IS_QUANT(mb_type)){
 853            h263_decode_dquant(s);
 854        }
 855
 856        if(IS_DIRECT(mb_type)){
 857            s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
 858            mb_type |= set_direct_mv(s);
 859        }else{
 860            s->mv_dir = 0;
 861            s->mv_type= MV_TYPE_16X16;
 862//FIXME UMV
 863
 864            if(USES_LIST(mb_type, 0)){
 865                int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
 866                s->mv_dir = MV_DIR_FORWARD;
 867
 868                if (s->umvplus)
 869                    mx = h263p_decode_umotion(s, pred_x);
 870                else
 871                    mx = ff_h263_decode_motion(s, pred_x, 1);
 872                if (mx >= 0xffff)
 873                    return SLICE_ERROR;
 874
 875                if (s->umvplus)
 876                    my = h263p_decode_umotion(s, pred_y);
 877                else
 878                    my = ff_h263_decode_motion(s, pred_y, 1);
 879                if (my >= 0xffff)
 880                    return SLICE_ERROR;
 881
 882                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
 883                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
 884
 885                s->mv[0][0][0] = mx;
 886                s->mv[0][0][1] = my;
 887                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
 888                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
 889            }
 890
 891            if(USES_LIST(mb_type, 1)){
 892                int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &pred_x, &pred_y);
 893                s->mv_dir |= MV_DIR_BACKWARD;
 894
 895                if (s->umvplus)
 896                    mx = h263p_decode_umotion(s, pred_x);
 897                else
 898                    mx = ff_h263_decode_motion(s, pred_x, 1);
 899                if (mx >= 0xffff)
 900                    return SLICE_ERROR;
 901
 902                if (s->umvplus)
 903                    my = h263p_decode_umotion(s, pred_y);
 904                else
 905                    my = ff_h263_decode_motion(s, pred_y, 1);
 906                if (my >= 0xffff)
 907                    return SLICE_ERROR;
 908
 909                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
 910                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
 911
 912                s->mv[1][0][0] = mx;
 913                s->mv[1][0][1] = my;
 914                mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
 915                mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
 916            }
 917        }
 918
 919        s->current_picture.mb_type[xy] = mb_type;
 920    } else { /* I-Frame */
 921        do{
 922            cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
 923            if (cbpc < 0){
 924                av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
 925                return SLICE_ERROR;
 926            }
 927        }while(cbpc == 8);
 928
 929        s->bdsp.clear_blocks(s->block[0]);
 930
 931        dquant = cbpc & 4;
 932        s->mb_intra = 1;
 933intra:
 934        s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
 935        if (s->h263_aic) {
 936            s->ac_pred = get_bits1(&s->gb);
 937            if(s->ac_pred){
 938                s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
 939
 940                s->h263_aic_dir = get_bits1(&s->gb);
 941            }
 942        }else
 943            s->ac_pred = 0;
 944
 945        if(s->pb_frame && get_bits1(&s->gb))
 946            pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
 947        cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 948        if(cbpy<0){
 949            av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
 950            return SLICE_ERROR;
 951        }
 952        cbp = (cbpc & 3) | (cbpy << 2);
 953        if (dquant) {
 954            h263_decode_dquant(s);
 955        }
 956
 957        pb_mv_count += !!s->pb_frame;
 958    }
 959
 960    while(pb_mv_count--){
 961        ff_h263_decode_motion(s, 0, 1);
 962        ff_h263_decode_motion(s, 0, 1);
 963    }
 964
 965    /* decode each block */
 966    for (i = 0; i < 6; i++) {
 967        if (h263_decode_block(s, block[i], i, cbp&32) < 0)
 968            return -1;
 969        cbp+=cbp;
 970    }
 971
 972    if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)
 973        return -1;
 974    if(s->obmc && !s->mb_intra){
 975        if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
 976            preview_obmc(s);
 977    }
 978end:
 979
 980    if (get_bits_left(&s->gb) < 0)
 981        return AVERROR_INVALIDDATA;
 982
 983        /* per-MB end of slice check */
 984    {
 985        int v= show_bits(&s->gb, 16);
 986
 987        if (get_bits_left(&s->gb) < 16) {
 988            v >>= 16 - get_bits_left(&s->gb);
 989        }
 990
 991        if(v==0)
 992            return SLICE_END;
 993    }
 994
 995    return SLICE_OK;
 996}
 997
 998/* Most is hardcoded; should extend to handle all H.263 streams. */
 999int ff_h263_decode_picture_header(MpegEncContext *s)
1000{
1001    int format, width, height, i, ret;
1002    uint32_t startcode;
1003
1004    align_get_bits(&s->gb);
1005
1006    if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_number == 0) {
1007         av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n");
1008    }
1009
1010    startcode= get_bits(&s->gb, 22-8);
1011
1012    for(i= get_bits_left(&s->gb); i>24; i-=8) {
1013        startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
1014
1015        if(startcode == 0x20)
1016            break;
1017    }
1018
1019    if (startcode != 0x20) {
1020        av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
1021        return -1;
1022    }
1023    /* temporal reference */
1024    i = get_bits(&s->gb, 8); /* picture timestamp */
1025
1026    i -= (i - (s->picture_number & 0xFF) + 128) & ~0xFF;
1027
1028    s->picture_number= (s->picture_number&~0xFF) + i;
1029
1030    /* PTYPE starts here */
1031    if (check_marker(s->avctx, &s->gb, "in PTYPE") != 1) {
1032        return -1;
1033    }
1034    if (get_bits1(&s->gb) != 0) {
1035        av_log(s->avctx, AV_LOG_ERROR, "Bad H.263 id\n");
1036        return -1;      /* H.263 id */
1037    }
1038    skip_bits1(&s->gb);         /* split screen off */
1039    skip_bits1(&s->gb);         /* camera  off */
1040    skip_bits1(&s->gb);         /* freeze picture release off */
1041
1042    format = get_bits(&s->gb, 3);
1043    /*
1044        0    forbidden
1045        1    sub-QCIF
1046        10   QCIF
1047        7       extended PTYPE (PLUSPTYPE)
1048    */
1049
1050    if (format != 7 && format != 6) {
1051        s->h263_plus = 0;
1052        /* H.263v1 */
1053        width = ff_h263_format[format][0];
1054        height = ff_h263_format[format][1];
1055        if (!width)
1056            return -1;
1057
1058        s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb);
1059
1060        s->h263_long_vectors = get_bits1(&s->gb);
1061
1062        if (get_bits1(&s->gb) != 0) {
1063            av_log(s->avctx, AV_LOG_ERROR, "H.263 SAC not supported\n");
1064            return -1; /* SAC: off */
1065        }
1066        s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
1067        s->unrestricted_mv = s->h263_long_vectors || s->obmc;
1068
1069        s->pb_frame = get_bits1(&s->gb);
1070        s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1071        skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1072
1073        s->width = width;
1074        s->height = height;
1075        s->avctx->sample_aspect_ratio= (AVRational){12,11};
1076        s->avctx->framerate = (AVRational){ 30000, 1001 };
1077    } else {
1078        int ufep;
1079
1080        /* H.263v2 */
1081        s->h263_plus = 1;
1082        ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1083
1084        /* ufep other than 0 and 1 are reserved */
1085        if (ufep == 1) {
1086            /* OPPTYPE */
1087            format = get_bits(&s->gb, 3);
1088            ff_dlog(s->avctx, "ufep=1, format: %d\n", format);
1089            s->custom_pcf= get_bits1(&s->gb);
1090            s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
1091            if (get_bits1(&s->gb) != 0) {
1092                av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
1093            }
1094            s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
1095            s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
1096            s->loop_filter= get_bits1(&s->gb);
1097            s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
1098            if(s->avctx->lowres)
1099                s->loop_filter = 0;
1100
1101            s->h263_slice_structured= get_bits1(&s->gb);
1102            if (get_bits1(&s->gb) != 0) {
1103                av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
1104            }
1105            if (get_bits1(&s->gb) != 0) {
1106                av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
1107            }
1108            s->alt_inter_vlc= get_bits1(&s->gb);
1109            s->modified_quant= get_bits1(&s->gb);
1110            if(s->modified_quant)
1111                s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1112
1113            skip_bits(&s->gb, 1); /* Prevent start code emulation */
1114
1115            skip_bits(&s->gb, 3); /* Reserved */
1116        } else if (ufep != 0) {
1117            av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
1118            return -1;
1119        }
1120
1121        /* MPPTYPE */
1122        s->pict_type = get_bits(&s->gb, 3);
1123        switch(s->pict_type){
1124        case 0: s->pict_type= AV_PICTURE_TYPE_I;break;
1125        case 1: s->pict_type= AV_PICTURE_TYPE_P;break;
1126        case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break;
1127        case 3: s->pict_type= AV_PICTURE_TYPE_B;break;
1128        case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO
1129        default:
1130            return -1;
1131        }
1132        skip_bits(&s->gb, 2);
1133        s->no_rounding = get_bits1(&s->gb);
1134        skip_bits(&s->gb, 4);
1135
1136        /* Get the picture dimensions */
1137        if (ufep) {
1138            if (format == 6) {
1139                /* Custom Picture Format (CPFMT) */
1140                s->aspect_ratio_info = get_bits(&s->gb, 4);
1141                ff_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
1142                /* aspect ratios:
1143                0 - forbidden
1144                1 - 1:1
1145                2 - 12:11 (CIF 4:3)
1146                3 - 10:11 (525-type 4:3)
1147                4 - 16:11 (CIF 16:9)
1148                5 - 40:33 (525-type 16:9)
1149                6-14 - reserved
1150                */
1151                width = (get_bits(&s->gb, 9) + 1) * 4;
1152                check_marker(s->avctx, &s->gb, "in dimensions");
1153                height = get_bits(&s->gb, 9) * 4;
1154                ff_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
1155                if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
1156                    /* expected dimensions */
1157                    s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
1158                    s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
1159                }else{
1160                    s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info];
1161                }
1162            } else {
1163                width = ff_h263_format[format][0];
1164                height = ff_h263_format[format][1];
1165                s->avctx->sample_aspect_ratio= (AVRational){12,11};
1166            }
1167            s->avctx->sample_aspect_ratio.den <<= s->ehc_mode;
1168            if ((width == 0) || (height == 0))
1169                return -1;
1170            s->width = width;
1171            s->height = height;
1172
1173            if(s->custom_pcf){
1174                int gcd;
1175                s->avctx->framerate.num  = 1800000;
1176                s->avctx->framerate.den  = 1000 + get_bits1(&s->gb);
1177                s->avctx->framerate.den *= get_bits(&s->gb, 7);
1178                if(s->avctx->framerate.den == 0){
1179                    av_log(s, AV_LOG_ERROR, "zero framerate\n");
1180                    return -1;
1181                }
1182                gcd= av_gcd(s->avctx->framerate.den, s->avctx->framerate.num);
1183                s->avctx->framerate.den /= gcd;
1184                s->avctx->framerate.num /= gcd;
1185            }else{
1186                s->avctx->framerate = (AVRational){ 30000, 1001 };
1187            }
1188        }
1189
1190        if(s->custom_pcf){
1191            skip_bits(&s->gb, 2); //extended Temporal reference
1192        }
1193
1194        if (ufep) {
1195            if (s->umvplus) {
1196                if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1197                    skip_bits1(&s->gb);
1198            }
1199            if(s->h263_slice_structured){
1200                if (get_bits1(&s->gb) != 0) {
1201                    av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
1202                }
1203                if (get_bits1(&s->gb) != 0) {
1204                    av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
1205                }
1206            }
1207            if (s->pict_type == AV_PICTURE_TYPE_B) {
1208                skip_bits(&s->gb, 4); //ELNUM
1209                if (ufep == 1) {
1210                    skip_bits(&s->gb, 4); // RLNUM
1211                }
1212            }
1213        }
1214
1215        s->qscale = get_bits(&s->gb, 5);
1216    }
1217
1218    if ((ret = av_image_check_size(s->width, s->height, 0, s)) < 0)
1219        return ret;
1220
1221    if (!(s->avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1222        if ((s->width * s->height / 256 / 8) > get_bits_left(&s->gb))
1223            return AVERROR_INVALIDDATA;
1224    }
1225
1226    s->mb_width = (s->width  + 15) / 16;
1227    s->mb_height = (s->height  + 15) / 16;
1228    s->mb_num = s->mb_width * s->mb_height;
1229
1230    if (s->pb_frame) {
1231        skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */
1232        if (s->custom_pcf)
1233            skip_bits(&s->gb, 2); //extended Temporal reference
1234        skip_bits(&s->gb, 2); /* Quantization information for B-pictures */
1235    }
1236
1237    if (s->pict_type!=AV_PICTURE_TYPE_B) {
1238        s->time            = s->picture_number;
1239        s->pp_time         = s->time - s->last_non_b_time;
1240        s->last_non_b_time = s->time;
1241    }else{
1242        s->time    = s->picture_number;
1243        s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
1244        if (s->pp_time <=s->pb_time ||
1245            s->pp_time <= s->pp_time - s->pb_time ||
1246            s->pp_time <= 0){
1247            s->pp_time = 2;
1248            s->pb_time = 1;
1249        }
1250        ff_mpeg4_init_direct_mv(s);
1251    }
1252
1253    /* PEI */
1254    if (skip_1stop_8data_bits(&s->gb) < 0)
1255        return AVERROR_INVALIDDATA;
1256
1257    if(s->h263_slice_structured){
1258        if (check_marker(s->avctx, &s->gb, "SEPB1") != 1) {
1259            return -1;
1260        }
1261
1262        ff_h263_decode_mba(s);
1263
1264        if (check_marker(s->avctx, &s->gb, "SEPB2") != 1) {
1265            return -1;
1266        }
1267    }
1268    s->f_code = 1;
1269
1270    if (s->pict_type == AV_PICTURE_TYPE_B)
1271        s->low_delay = 0;
1272
1273    if(s->h263_aic){
1274         s->y_dc_scale_table=
1275         s->c_dc_scale_table= ff_aic_dc_scale_table;
1276    }else{
1277        s->y_dc_scale_table=
1278        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1279    }
1280
1281        ff_h263_show_pict_info(s);
1282    if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){
1283        int i,j;
1284        for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1285        av_log(s->avctx, AV_LOG_DEBUG, "\n");
1286        for(i=0; i<13; i++){
1287            for(j=0; j<3; j++){
1288                int v= get_bits(&s->gb, 8);
1289                v |= get_sbits(&s->gb, 8) * (1 << 8);
1290                av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
1291            }
1292            av_log(s->avctx, AV_LOG_DEBUG, "\n");
1293        }
1294        for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1295    }
1296
1297    return 0;
1298}