Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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