falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
45418 Commits
32 Branches
596MB
Tree: efb0e4e7af
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'efb0e4e7af'
${ noResults }
FFmpeg/libavcodec/ituh263dec.c

1152 lines
37KB
Raw Blame History 

  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. 

  32. //#define DEBUG

  33. #include <limits.h>

  34. 

  35. #include "libavutil/mathematics.h"

  36. #include "dsputil.h"

  37. #include "avcodec.h"

  38. #include "mpegvideo.h"

  39. #include "h263.h"

  40. #include "mathops.h"

  41. #include "unary.h"

  42. #include "flv.h"

  43. #include "mpeg4video.h"

  44. 

  45. // The defines below define the number of bits that are read at once for

  46. // reading vlc values. Changing these may improve speed and data cache needs

  47. // be aware though that decreasing them may need the number of stages that is

  48. // passed to get_vlc* to be increased.

  49. #define MV_VLC_BITS 9

  50. #define H263_MBTYPE_B_VLC_BITS 6

  51. #define CBPC_B_VLC_BITS 3

  52. 

  53. static const int h263_mb_type_b_map[15]= {

  54.     MB_TYPE_DIRECT2 | MB_TYPE_L0L1,

  55.     MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP,

  56.     MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT,

  57.                       MB_TYPE_L0                                 | MB_TYPE_16x16,

  58.                       MB_TYPE_L0   | MB_TYPE_CBP                 | MB_TYPE_16x16,

  59.                       MB_TYPE_L0   | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,

  60.                       MB_TYPE_L1                                 | MB_TYPE_16x16,

  61.                       MB_TYPE_L1   | MB_TYPE_CBP                 | MB_TYPE_16x16,

  62.                       MB_TYPE_L1   | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,

  63.                       MB_TYPE_L0L1                               | MB_TYPE_16x16,

  64.                       MB_TYPE_L0L1 | MB_TYPE_CBP                 | MB_TYPE_16x16,

  65.                       MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,

  66.     0, //stuffing

  67.     MB_TYPE_INTRA4x4                | MB_TYPE_CBP,

  68.     MB_TYPE_INTRA4x4                | MB_TYPE_CBP | MB_TYPE_QUANT,

  69. };

  70. 

  71. void ff_h263_show_pict_info(MpegEncContext *s){

  72.     if(s->avctx->debug&FF_DEBUG_PICT_INFO){

  73.     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",

  74.          s->qscale, av_get_picture_type_char(s->pict_type),

  75.          s->gb.size_in_bits, 1-s->no_rounding,

  76.          s->obmc ? " AP" : "",

  77.          s->umvplus ? " UMV" : "",

  78.          s->h263_long_vectors ? " LONG" : "",

  79.          s->h263_plus ? " +" : "",

  80.          s->h263_aic ? " AIC" : "",

  81.          s->alt_inter_vlc ? " AIV" : "",

  82.          s->modified_quant ? " MQ" : "",

  83.          s->loop_filter ? " LOOP" : "",

  84.          s->h263_slice_structured ? " SS" : "",

  85.          s->avctx->time_base.den, s->avctx->time_base.num

  86.     );

  87.     }

  88. }

  89. 

  90. /***********************************************/

  91. /* decoding */

  92. 

  93. VLC ff_h263_intra_MCBPC_vlc;

  94. VLC ff_h263_inter_MCBPC_vlc;

  95. VLC ff_h263_cbpy_vlc;

  96. static VLC mv_vlc;

  97. static VLC h263_mbtype_b_vlc;

  98. static VLC cbpc_b_vlc;

  99. 

  100. /* init vlcs */

  101. 

  102. /* XXX: find a better solution to handle static init */

  103. void ff_h263_decode_init_vlc(MpegEncContext *s)

  104. {

  105.     static int done = 0;

  106. 

  107.     if (!done) {

  108.         done = 1;

  109. 

  110.         INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,

  111.                  ff_h263_intra_MCBPC_bits, 1, 1,

  112.                  ff_h263_intra_MCBPC_code, 1, 1, 72);

  113.         INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,

  114.                  ff_h263_inter_MCBPC_bits, 1, 1,

  115.                  ff_h263_inter_MCBPC_code, 1, 1, 198);

  116.         INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16,

  117.                  &ff_h263_cbpy_tab[0][1], 2, 1,

  118.                  &ff_h263_cbpy_tab[0][0], 2, 1, 64);

  119.         INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33,

  120.                  &ff_mvtab[0][1], 2, 1,

  121.                  &ff_mvtab[0][0], 2, 1, 538);

  122.         ff_init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);

  123.         ff_init_rl(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);

  124.         INIT_VLC_RL(ff_h263_rl_inter, 554);

  125.         INIT_VLC_RL(ff_rl_intra_aic, 554);

  126.         INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,

  127.                  &ff_h263_mbtype_b_tab[0][1], 2, 1,

  128.                  &ff_h263_mbtype_b_tab[0][0], 2, 1, 80);

  129.         INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,

  130.                  &ff_cbpc_b_tab[0][1], 2, 1,

  131.                  &ff_cbpc_b_tab[0][0], 2, 1, 8);

  132.     }

  133. }

  134. 

  135. int ff_h263_decode_mba(MpegEncContext *s)

  136. {

  137.     int i, mb_pos;

  138. 

  139.     for(i=0; i<6; i++){

  140.         if(s->mb_num-1 <= ff_mba_max[i]) break;

  141.     }

  142.     mb_pos= get_bits(&s->gb, ff_mba_length[i]);

  143.     s->mb_x= mb_pos % s->mb_width;

  144.     s->mb_y= mb_pos / s->mb_width;

  145. 

  146.     return mb_pos;

  147. }

  148. 

  149. /**

  150.  * Decode the group of blocks header or slice header.

  151.  * @return <0 if an error occurred

  152.  */

  153. static int h263_decode_gob_header(MpegEncContext *s)

  154. {

  155.     unsigned int val, gob_number;

  156.     int left;

  157. 

  158.     /* Check for GOB Start Code */

  159.     val = show_bits(&s->gb, 16);

  160.     if(val)

  161.         return -1;

  162. 

  163.         /* We have a GBSC probably with GSTUFF */

  164.     skip_bits(&s->gb, 16); /* Drop the zeros */

  165.     left= get_bits_left(&s->gb);

  166.     //MN: we must check the bits left or we might end in a infinite loop (or segfault)

  167.     for(;left>13; left--){

  168.         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */

  169.     }

  170.     if(left<=13)

  171.         return -1;

  172. 

  173.     if(s->h263_slice_structured){

  174.         if(get_bits1(&s->gb)==0)

  175.             return -1;

  176. 

  177.         ff_h263_decode_mba(s);

  178. 

  179.         if(s->mb_num > 1583)

  180.             if(get_bits1(&s->gb)==0)

  181.                 return -1;

  182. 

  183.         s->qscale = get_bits(&s->gb, 5); /* SQUANT */

  184.         if(get_bits1(&s->gb)==0)

  185.             return -1;

  186.         skip_bits(&s->gb, 2); /* GFID */

  187.     }else{

  188.         gob_number = get_bits(&s->gb, 5); /* GN */

  189.         s->mb_x= 0;

  190.         s->mb_y= s->gob_index* gob_number;

  191.         skip_bits(&s->gb, 2); /* GFID */

  192.         s->qscale = get_bits(&s->gb, 5); /* GQUANT */

  193.     }

  194. 

  195.     if(s->mb_y >= s->mb_height)

  196.         return -1;

  197. 

  198.     if(s->qscale==0)

  199.         return -1;

  200. 

  201.     return 0;

  202. }

  203. 

  204. /**

  205.  * Find the next resync_marker.

  206.  * @param p pointer to buffer to scan

  207.  * @param end pointer to the end of the buffer

  208.  * @return pointer to the next resync_marker, or end if none was found

  209.  */

  210. const uint8_t *ff_h263_find_resync_marker(MpegEncContext *s, const uint8_t *av_restrict p, const uint8_t *av_restrict end)

  211. {

  212.     av_assert2(p < end);

  213. 

  214.     end-=2;

  215.     p++;

  216.     if(s->resync_marker){

  217.         int prefix_len = ff_mpeg4_get_video_packet_prefix_length(s);

  218.         for(;p<end; p+=2){

  219.             if(!*p){

  220.                 if      (!p[-1] && ((p[1] >> (23-prefix_len)) == 1)) return p - 1;

  221.                 else if (!p[ 1] && ((p[2] >> (23-prefix_len)) == 1)) return p;

  222.             }

  223.         }

  224.     }

  225.     return end+2;

  226. }

  227. 

  228. /**

  229.  * Decode the group of blocks / video packet header.

  230.  * @return bit position of the resync_marker, or <0 if none was found

  231.  */

  232. int ff_h263_resync(MpegEncContext *s){

  233.     int left, pos, ret;

  234. 

  235.     if(s->codec_id==AV_CODEC_ID_MPEG4){

  236.         skip_bits1(&s->gb);

  237.         align_get_bits(&s->gb);

  238.     }

  239. 

  240.     if(show_bits(&s->gb, 16)==0){

  241.         pos= get_bits_count(&s->gb);

  242.         if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)

  243.             ret= ff_mpeg4_decode_video_packet_header(s);

  244.         else

  245.             ret= h263_decode_gob_header(s);

  246.         if(ret>=0)

  247.             return pos;

  248.     }

  249.     //OK, it's not where it is supposed to be ...

  250.     s->gb= s->last_resync_gb;

  251.     align_get_bits(&s->gb);

  252.     left= get_bits_left(&s->gb);

  253. 

  254.     for(;left>16+1+5+5; left-=8){

  255.         if(show_bits(&s->gb, 16)==0){

  256.             GetBitContext bak= s->gb;

  257. 

  258.             pos= get_bits_count(&s->gb);

  259.             if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)

  260.                 ret= ff_mpeg4_decode_video_packet_header(s);

  261.             else

  262.                 ret= h263_decode_gob_header(s);

  263.             if(ret>=0)

  264.                 return pos;

  265. 

  266.             s->gb= bak;

  267.         }

  268.         skip_bits(&s->gb, 8);

  269.     }

  270. 

  271.     return -1;

  272. }

  273. 

  274. int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code)

  275. {

  276.     int code, val, sign, shift;

  277.     code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);

  278. 

  279.     if (code == 0)

  280.         return pred;

  281.     if (code < 0)

  282.         return 0xffff;

  283. 

  284.     sign = get_bits1(&s->gb);

  285.     shift = f_code - 1;

  286.     val = code;

  287.     if (shift) {

  288.         val = (val - 1) << shift;

  289.         val |= get_bits(&s->gb, shift);

  290.         val++;

  291.     }

  292.     if (sign)

  293.         val = -val;

  294.     val += pred;

  295. 

  296.     /* modulo decoding */

  297.     if (!s->h263_long_vectors) {

  298.         val = sign_extend(val, 5 + f_code);

  299.     } else {

  300.         /* horrible h263 long vector mode */

  301.         if (pred < -31 && val < -63)

  302.             val += 64;

  303.         if (pred > 32 && val > 63)

  304.             val -= 64;

  305. 

  306.     }

  307.     return val;

  308. }

  309. 

  310. 

  311. /* Decode RVLC of H.263+ UMV */

  312. static int h263p_decode_umotion(MpegEncContext * s, int pred)

  313. {

  314.    int code = 0, sign;

  315. 

  316.    if (get_bits1(&s->gb)) /* Motion difference = 0 */

  317.       return pred;

  318. 

  319.    code = 2 + get_bits1(&s->gb);

  320. 

  321.    while (get_bits1(&s->gb))

  322.    {

  323.       code <<= 1;

  324.       code += get_bits1(&s->gb);

  325.    }

  326.    sign = code & 1;

  327.    code >>= 1;

  328. 

  329.    code = (sign) ? (pred - code) : (pred + code);

  330.    av_dlog(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 a ugly hack, feel free to send a patch :)

  337.  */

  338. static 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.f.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.f.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.f.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.f.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.f.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.     }

  419. end:

  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. 

  430. static 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. 

  443. static int h263_decode_block(MpegEncContext * s, DCTELEM * block,

  444.                              int n, int coded)

  445. {

  446.     int code, level, i, j, last, 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(s->codec_id == AV_CODEC_ID_RV10){

  464. #if CONFIG_RV10_DECODER

  465.           if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) {

  466.             int component, diff;

  467.             component = (n <= 3 ? 0 : n - 4 + 1);

  468.             level = s->last_dc[component];

  469.             if (s->rv10_first_dc_coded[component]) {

  470.                 diff = ff_rv_decode_dc(s, n);

  471.                 if (diff == 0xffff)

  472.                     return -1;

  473.                 level += diff;

  474.                 level = level & 0xff; /* handle wrap round */

  475.                 s->last_dc[component] = level;

  476.             } else {

  477.                 s->rv10_first_dc_coded[component] = 1;

  478.             }

  479.           } else {

  480.                 level = get_bits(&s->gb, 8);

  481.                 if (level == 255)

  482.                     level = 128;

  483.           }

  484. #endif

  485.         }else{

  486.             level = get_bits(&s->gb, 8);

  487.             if((level&0x7F) == 0){

  488.                 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);

  489.                 if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))

  490.                     return -1;

  491.             }

  492.             if (level == 255)

  493.                 level = 128;

  494.         }

  495.         block[0] = level;

  496.         i = 1;

  497.     } else {

  498.         i = 0;

  499.     }

  500.     if (!coded) {

  501.         if (s->mb_intra && s->h263_aic)

  502.             goto not_coded;

  503.         s->block_last_index[n] = i - 1;

  504.         return 0;

  505.     }

  506. retry:

  507.     for(;;) {

  508.         code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);

  509.         if (code < 0){

  510.             av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);

  511.             return -1;

  512.         }

  513.         if (code == rl->n) {

  514.             /* escape */

  515.             if (CONFIG_FLV_DECODER && s->h263_flv > 1) {

  516.                 ff_flv2_decode_ac_esc(&s->gb, &level, &run, &last);

  517.             } else {

  518.                 last = get_bits1(&s->gb);

  519.                 run = get_bits(&s->gb, 6);

  520.                 level = (int8_t)get_bits(&s->gb, 8);

  521.                 if(level == -128){

  522.                     if (s->codec_id == AV_CODEC_ID_RV10) {

  523.                         /* XXX: should patch encoder too */

  524.                         level = get_sbits(&s->gb, 12);

  525.                     }else{

  526.                         level = get_bits(&s->gb, 5);

  527.                         level |= get_sbits(&s->gb, 6)<<5;

  528.                     }

  529.                 }

  530.             }

  531.         } else {

  532.             run = rl->table_run[code];

  533.             level = rl->table_level[code];

  534.             last = code >= rl->last;

  535.             if (get_bits1(&s->gb))

  536.                 level = -level;

  537.         }

  538.         i += run;

  539.         if (i >= 64){

  540.             if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){

  541.                 //Looks like a hack but no, it's the way it is supposed to work ...

  542.                 rl = &ff_rl_intra_aic;

  543.                 i = 0;

  544.                 s->gb= gb;

  545.                 s->dsp.clear_block(block);

  546.                 goto retry;

  547.             }

  548.             av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);

  549.             return -1;

  550.         }

  551.         j = scan_table[i];

  552.         block[j] = level;

  553.         if (last)

  554.             break;

  555.         i++;

  556.     }

  557. not_coded:

  558.     if (s->mb_intra && s->h263_aic) {

  559.         ff_h263_pred_acdc(s, block, n);

  560.         i = 63;

  561.     }

  562.     s->block_last_index[n] = i;

  563.     return 0;

  564. }

  565. 

  566. static int h263_skip_b_part(MpegEncContext *s, int cbp)

  567. {

  568.     LOCAL_ALIGNED_16(DCTELEM, dblock, [64]);

  569.     int i, mbi;

  570. 

  571.     /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly

  572.      * but real value should be restored in order to be used later (in OBMC condition)

  573.      */

  574.     mbi = s->mb_intra;

  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.     return 0;

  583. }

  584. 

  585. static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)

  586. {

  587.     int c, mv = 1;

  588. 

  589.     if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame

  590.         c = get_bits1(gb);

  591.         if (pb_frame == 2 && c)

  592.             mv = !get_bits1(gb);

  593.     } else { // h.263 Annex M improved PB-frame

  594.         mv = get_unary(gb, 0, 4) + 1;

  595.         c = mv & 1;

  596.         mv = !!(mv & 2);

  597.     }

  598.     if(c)

  599.         *cbpb = get_bits(gb, 6);

  600.     return mv;

  601. }

  602. 

  603. int ff_h263_decode_mb(MpegEncContext *s,

  604.                       DCTELEM block[6][64])

  605. {

  606.     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

  607.     int16_t *mot_val;

  608.     const int xy= s->mb_x + s->mb_y * s->mb_stride;

  609.     int cbpb = 0, pb_mv_count = 0;

  610. 

  611.     av_assert2(!s->h263_pred);

  612. 

  613.     if (s->pict_type == AV_PICTURE_TYPE_P) {

  614.         do{

  615.             if (get_bits1(&s->gb)) {

  616.                 /* skip mb */

  617.                 s->mb_intra = 0;

  618.                 for(i=0;i<6;i++)

  619.                     s->block_last_index[i] = -1;

  620.                 s->mv_dir = MV_DIR_FORWARD;

  621.                 s->mv_type = MV_TYPE_16X16;

  622.                 s->current_picture.f.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;

  623.                 s->mv[0][0][0] = 0;

  624.                 s->mv[0][0][1] = 0;

  625.                 s->mb_skipped = !(s->obmc | s->loop_filter);

  626.                 goto end;

  627.             }

  628.             cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

  629.             if (cbpc < 0){

  630.                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);

  631.                 return -1;

  632.             }

  633.         }while(cbpc == 20);

  634. 

  635.         s->dsp.clear_blocks(s->block[0]);

  636. 

  637.         dquant = cbpc & 8;

  638.         s->mb_intra = ((cbpc & 4) != 0);

  639.         if (s->mb_intra) goto intra;

  640. 

  641.         if(s->pb_frame && get_bits1(&s->gb))

  642.             pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);

  643.         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);

  644. 

  645.         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)

  646.             cbpy ^= 0xF;

  647. 

  648.         cbp = (cbpc & 3) | (cbpy << 2);

  649.         if (dquant) {

  650.             h263_decode_dquant(s);

  651.         }

  652. 

  653.         s->mv_dir = MV_DIR_FORWARD;

  654.         if ((cbpc & 16) == 0) {

  655.             s->current_picture.f.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;

  656.             /* 16x16 motion prediction */

  657.             s->mv_type = MV_TYPE_16X16;

  658.             ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);

  659.             if (s->umvplus)

  660.                mx = h263p_decode_umotion(s, pred_x);

  661.             else

  662.                mx = ff_h263_decode_motion(s, pred_x, 1);

  663. 

  664.             if (mx >= 0xffff)

  665.                 return -1;

  666. 

  667.             if (s->umvplus)

  668.                my = h263p_decode_umotion(s, pred_y);

  669.             else

  670.                my = ff_h263_decode_motion(s, pred_y, 1);

  671. 

  672.             if (my >= 0xffff)

  673.                 return -1;

  674.             s->mv[0][0][0] = mx;

  675.             s->mv[0][0][1] = my;

  676. 

  677.             if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)

  678.                skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

  679.         } else {

  680.             s->current_picture.f.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;

  681.             s->mv_type = MV_TYPE_8X8;

  682.             for(i=0;i<4;i++) {

  683.                 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);

  684.                 if (s->umvplus)

  685.                   mx = h263p_decode_umotion(s, pred_x);

  686.                 else

  687.                   mx = ff_h263_decode_motion(s, pred_x, 1);

  688.                 if (mx >= 0xffff)

  689.                     return -1;

  690. 

  691.                 if (s->umvplus)

  692.                   my = h263p_decode_umotion(s, pred_y);

  693.                 else

  694.                   my = ff_h263_decode_motion(s, pred_y, 1);

  695.                 if (my >= 0xffff)

  696.                     return -1;

  697.                 s->mv[0][i][0] = mx;

  698.                 s->mv[0][i][1] = my;

  699.                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)

  700.                   skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

  701.                 mot_val[0] = mx;

  702.                 mot_val[1] = my;

  703.             }

  704.         }

  705.     } else if(s->pict_type==AV_PICTURE_TYPE_B) {

  706.         int mb_type;

  707.         const int stride= s->b8_stride;

  708.         int16_t *mot_val0 = s->current_picture.f.motion_val[0][2 * (s->mb_x + s->mb_y * stride)];

  709.         int16_t *mot_val1 = s->current_picture.f.motion_val[1][2 * (s->mb_x + s->mb_y * stride)];

  710. //        const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;

  711. 

  712.         //FIXME ugly

  713.         mot_val0[0       ]= mot_val0[2       ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=

  714.         mot_val0[1       ]= mot_val0[3       ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=

  715.         mot_val1[0       ]= mot_val1[2       ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=

  716.         mot_val1[1       ]= mot_val1[3       ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;

  717. 

  718.         do{

  719.             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);

  720.             if (mb_type < 0){

  721.                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);

  722.                 return -1;

  723.             }

  724. 

  725.             mb_type= h263_mb_type_b_map[ mb_type ];

  726.         }while(!mb_type);

  727. 

  728.         s->mb_intra = IS_INTRA(mb_type);

  729.         if(HAS_CBP(mb_type)){

  730.             s->dsp.clear_blocks(s->block[0]);

  731.             cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);

  732.             if(s->mb_intra){

  733.                 dquant = IS_QUANT(mb_type);

  734.                 goto intra;

  735.             }

  736. 

  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, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);

  741.                 return -1;

  742.             }

  743. 

  744.             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)

  745.                 cbpy ^= 0xF;

  746. 

  747.             cbp = (cbpc & 3) | (cbpy << 2);

  748.         }else

  749.             cbp=0;

  750. 

  751.         av_assert2(!s->mb_intra);

  752. 

  753.         if(IS_QUANT(mb_type)){

  754.             h263_decode_dquant(s);

  755.         }

  756. 

  757.         if(IS_DIRECT(mb_type)){

  758.             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;

  759.             mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);

  760.         }else{

  761.             s->mv_dir = 0;

  762.             s->mv_type= MV_TYPE_16X16;

  763. //FIXME UMV

  764. 

  765.             if(USES_LIST(mb_type, 0)){

  766.                 int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &mx, &my);

  767.                 s->mv_dir = MV_DIR_FORWARD;

  768. 

  769.                 mx = ff_h263_decode_motion(s, mx, 1);

  770.                 my = ff_h263_decode_motion(s, my, 1);

  771. 

  772.                 s->mv[0][0][0] = mx;

  773.                 s->mv[0][0][1] = my;

  774.                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;

  775.                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;

  776.             }

  777. 

  778.             if(USES_LIST(mb_type, 1)){

  779.                 int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &mx, &my);

  780.                 s->mv_dir |= MV_DIR_BACKWARD;

  781. 

  782.                 mx = ff_h263_decode_motion(s, mx, 1);

  783.                 my = ff_h263_decode_motion(s, my, 1);

  784. 

  785.                 s->mv[1][0][0] = mx;

  786.                 s->mv[1][0][1] = my;

  787.                 mot_val[0       ]= mot_val[2       ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;

  788.                 mot_val[1       ]= mot_val[3       ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;

  789.             }

  790.         }

  791. 

  792.         s->current_picture.f.mb_type[xy] = mb_type;

  793.     } else { /* I-Frame */

  794.         do{

  795.             cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);

  796.             if (cbpc < 0){

  797.                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);

  798.                 return -1;

  799.             }

  800.         }while(cbpc == 8);

  801. 

  802.         s->dsp.clear_blocks(s->block[0]);

  803. 

  804.         dquant = cbpc & 4;

  805.         s->mb_intra = 1;

  806. intra:

  807.         s->current_picture.f.mb_type[xy] = MB_TYPE_INTRA;

  808.         if (s->h263_aic) {

  809.             s->ac_pred = get_bits1(&s->gb);

  810.             if(s->ac_pred){

  811.                 s->current_picture.f.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;

  812. 

  813.                 s->h263_aic_dir = get_bits1(&s->gb);

  814.             }

  815.         }else

  816.             s->ac_pred = 0;

  817. 

  818.         if(s->pb_frame && get_bits1(&s->gb))

  819.             pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);

  820.         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);

  821.         if(cbpy<0){

  822.             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);

  823.             return -1;

  824.         }

  825.         cbp = (cbpc & 3) | (cbpy << 2);

  826.         if (dquant) {

  827.             h263_decode_dquant(s);

  828.         }

  829. 

  830.         pb_mv_count += !!s->pb_frame;

  831.     }

  832. 

  833.     while(pb_mv_count--){

  834.         ff_h263_decode_motion(s, 0, 1);

  835.         ff_h263_decode_motion(s, 0, 1);

  836.     }

  837. 

  838.     /* decode each block */

  839.     for (i = 0; i < 6; i++) {

  840.         if (h263_decode_block(s, block[i], i, cbp&32) < 0)

  841.             return -1;

  842.         cbp+=cbp;

  843.     }

  844. 

  845.     if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)

  846.         return -1;

  847.     if(s->obmc && !s->mb_intra){

  848.         if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1)

  849.             preview_obmc(s);

  850.     }

  851. end:

  852. 

  853.         /* per-MB end of slice check */

  854.     {

  855.         int v= show_bits(&s->gb, 16);

  856. 

  857.         if (get_bits_left(&s->gb) < 16) {

  858.             v >>= 16 - get_bits_left(&s->gb);

  859.         }

  860. 

  861.         if(v==0)

  862.             return SLICE_END;

  863.     }

  864. 

  865.     return SLICE_OK;

  866. }

  867. 

  868. /* most is hardcoded. should extend to handle all h263 streams */

  869. int ff_h263_decode_picture_header(MpegEncContext *s)

  870. {

  871.     int format, width, height, i;

  872.     uint32_t startcode;

  873. 

  874.     align_get_bits(&s->gb);

  875. 

  876.     startcode= get_bits(&s->gb, 22-8);

  877. 

  878.     for(i= get_bits_left(&s->gb); i>24; i-=8) {

  879.         startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;

  880. 

  881.         if(startcode == 0x20)

  882.             break;

  883.     }

  884. 

  885.     if (startcode != 0x20) {

  886.         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");

  887.         return -1;

  888.     }

  889.     /* temporal reference */

  890.     i = get_bits(&s->gb, 8); /* picture timestamp */

  891.     if( (s->picture_number&~0xFF)+i < s->picture_number)

  892.         i+= 256;

  893.     s->current_picture_ptr->f.pts =

  894.     s->picture_number= (s->picture_number&~0xFF) + i;

  895. 

  896.     /* PTYPE starts here */

  897.     if (get_bits1(&s->gb) != 1) {

  898.         /* marker */

  899.         av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");

  900.         return -1;

  901.     }

  902.     if (get_bits1(&s->gb) != 0) {

  903.         av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");

  904.         return -1;      /* h263 id */

  905.     }

  906.     skip_bits1(&s->gb);         /* split screen off */

  907.     skip_bits1(&s->gb);         /* camera  off */

  908.     skip_bits1(&s->gb);         /* freeze picture release off */

  909. 

  910.     format = get_bits(&s->gb, 3);

  911.     /*

  912.         0    forbidden

  913.         1    sub-QCIF

  914.         10   QCIF

  915.         7       extended PTYPE (PLUSPTYPE)

  916.     */

  917. 

  918.     if (format != 7 && format != 6) {

  919.         s->h263_plus = 0;

  920.         /* H.263v1 */

  921.         width = ff_h263_format[format][0];

  922.         height = ff_h263_format[format][1];

  923.         if (!width)

  924.             return -1;

  925. 

  926.         s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb);

  927. 

  928.         s->h263_long_vectors = get_bits1(&s->gb);

  929. 

  930.         if (get_bits1(&s->gb) != 0) {

  931.             av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");

  932.             return -1; /* SAC: off */

  933.         }

  934.         s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */

  935.         s->unrestricted_mv = s->h263_long_vectors || s->obmc;

  936. 

  937.         s->pb_frame = get_bits1(&s->gb);

  938.         s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);

  939.         skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */

  940. 

  941.         s->width = width;

  942.         s->height = height;

  943.         s->avctx->sample_aspect_ratio= (AVRational){12,11};

  944.         s->avctx->time_base= (AVRational){1001, 30000};

  945.     } else {

  946.         int ufep;

  947. 

  948.         /* H.263v2 */

  949.         s->h263_plus = 1;

  950.         ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */

  951. 

  952.         /* ufep other than 0 and 1 are reserved */

  953.         if (ufep == 1) {

  954.             /* OPPTYPE */

  955.             format = get_bits(&s->gb, 3);

  956.             av_dlog(s->avctx, "ufep=1, format: %d\n", format);

  957.             s->custom_pcf= get_bits1(&s->gb);

  958.             s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */

  959.             if (get_bits1(&s->gb) != 0) {

  960.                 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");

  961.             }

  962.             s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */

  963.             s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */

  964.             s->loop_filter= get_bits1(&s->gb);

  965.             s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;

  966.             if(s->avctx->lowres)

  967.                 s->loop_filter = 0;

  968. 

  969.             s->h263_slice_structured= get_bits1(&s->gb);

  970.             if (get_bits1(&s->gb) != 0) {

  971.                 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");

  972.             }

  973.             if (get_bits1(&s->gb) != 0) {

  974.                 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");

  975.             }

  976.             s->alt_inter_vlc= get_bits1(&s->gb);

  977.             s->modified_quant= get_bits1(&s->gb);

  978.             if(s->modified_quant)

  979.                 s->chroma_qscale_table= ff_h263_chroma_qscale_table;

  980. 

  981.             skip_bits(&s->gb, 1); /* Prevent start code emulation */

  982. 

  983.             skip_bits(&s->gb, 3); /* Reserved */

  984.         } else if (ufep != 0) {

  985.             av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);

  986.             return -1;

  987.         }

  988. 

  989.         /* MPPTYPE */

  990.         s->pict_type = get_bits(&s->gb, 3);

  991.         switch(s->pict_type){

  992.         case 0: s->pict_type= AV_PICTURE_TYPE_I;break;

  993.         case 1: s->pict_type= AV_PICTURE_TYPE_P;break;

  994.         case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break;

  995.         case 3: s->pict_type= AV_PICTURE_TYPE_B;break;

  996.         case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO

  997.         default:

  998.             return -1;

  999.         }

  1000.         skip_bits(&s->gb, 2);

  1001.         s->no_rounding = get_bits1(&s->gb);

  1002.         skip_bits(&s->gb, 4);

  1003. 

  1004.         /* Get the picture dimensions */

  1005.         if (ufep) {

  1006.             if (format == 6) {

  1007.                 /* Custom Picture Format (CPFMT) */

  1008.                 s->aspect_ratio_info = get_bits(&s->gb, 4);

  1009.                 av_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info);

  1010.                 /* aspect ratios:

  1011.                 0 - forbidden

  1012.                 1 - 1:1

  1013.                 2 - 12:11 (CIF 4:3)

  1014.                 3 - 10:11 (525-type 4:3)

  1015.                 4 - 16:11 (CIF 16:9)

  1016.                 5 - 40:33 (525-type 16:9)

  1017.                 6-14 - reserved

  1018.                 */

  1019.                 width = (get_bits(&s->gb, 9) + 1) * 4;

  1020.                 skip_bits1(&s->gb);

  1021.                 height = get_bits(&s->gb, 9) * 4;

  1022.                 av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);

  1023.                 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {

  1024.                     /* aspected dimensions */

  1025.                     s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);

  1026.                     s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);

  1027.                 }else{

  1028.                     s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info];

  1029.                 }

  1030.             } else {

  1031.                 width = ff_h263_format[format][0];

  1032.                 height = ff_h263_format[format][1];

  1033.                 s->avctx->sample_aspect_ratio= (AVRational){12,11};

  1034.             }

  1035.             if ((width == 0) || (height == 0))

  1036.                 return -1;

  1037.             s->width = width;

  1038.             s->height = height;

  1039. 

  1040.             if(s->custom_pcf){

  1041.                 int gcd;

  1042.                 s->avctx->time_base.den= 1800000;

  1043.                 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);

  1044.                 s->avctx->time_base.num*= get_bits(&s->gb, 7);

  1045.                 if(s->avctx->time_base.num == 0){

  1046.                     av_log(s, AV_LOG_ERROR, "zero framerate\n");

  1047.                     return -1;

  1048.                 }

  1049.                 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num);

  1050.                 s->avctx->time_base.den /= gcd;

  1051.                 s->avctx->time_base.num /= gcd;

  1052.             }else{

  1053.                 s->avctx->time_base= (AVRational){1001, 30000};

  1054.             }

  1055.         }

  1056. 

  1057.         if(s->custom_pcf){

  1058.             skip_bits(&s->gb, 2); //extended Temporal reference

  1059.         }

  1060. 

  1061.         if (ufep) {

  1062.             if (s->umvplus) {

  1063.                 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

  1064.                     skip_bits1(&s->gb);

  1065.             }

  1066.             if(s->h263_slice_structured){

  1067.                 if (get_bits1(&s->gb) != 0) {

  1068.                     av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");

  1069.                 }

  1070.                 if (get_bits1(&s->gb) != 0) {

  1071.                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");

  1072.                 }

  1073.             }

  1074.         }

  1075. 

  1076.         s->qscale = get_bits(&s->gb, 5);

  1077.     }

  1078. 

  1079.     s->mb_width = (s->width  + 15) / 16;

  1080.     s->mb_height = (s->height  + 15) / 16;

  1081.     s->mb_num = s->mb_width * s->mb_height;

  1082. 

  1083.     if (s->pb_frame) {

  1084.         skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */

  1085.         if (s->custom_pcf)

  1086.             skip_bits(&s->gb, 2); //extended Temporal reference

  1087.         skip_bits(&s->gb, 2); /* Quantization information for B-pictures */

  1088.     }

  1089. 

  1090.     if (s->pict_type!=AV_PICTURE_TYPE_B) {

  1091.         s->time            = s->picture_number;

  1092.         s->pp_time         = s->time - s->last_non_b_time;

  1093.         s->last_non_b_time = s->time;

  1094.     }else{

  1095.         s->time    = s->picture_number;

  1096.         s->pb_time = s->pp_time - (s->last_non_b_time - s->time);

  1097.         if (s->pp_time <=s->pb_time ||

  1098.             s->pp_time <= s->pp_time - s->pb_time ||

  1099.             s->pp_time <= 0){

  1100.             s->pp_time = 2;

  1101.             s->pb_time = 1;

  1102.         }

  1103.         ff_mpeg4_init_direct_mv(s);

  1104.     }

  1105. 

  1106.     /* PEI */

  1107.     while (get_bits1(&s->gb) != 0) {

  1108.         skip_bits(&s->gb, 8);

  1109.     }

  1110. 

  1111.     if(s->h263_slice_structured){

  1112.         if (get_bits1(&s->gb) != 1) {

  1113.             av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");

  1114.             return -1;

  1115.         }

  1116. 

  1117.         ff_h263_decode_mba(s);

  1118. 

  1119.         if (get_bits1(&s->gb) != 1) {

  1120.             av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");

  1121.             return -1;

  1122.         }

  1123.     }

  1124.     s->f_code = 1;

  1125. 

  1126.     if(s->h263_aic){

  1127.          s->y_dc_scale_table=

  1128.          s->c_dc_scale_table= ff_aic_dc_scale_table;

  1129.     }else{

  1130.         s->y_dc_scale_table=

  1131.         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;

  1132.     }

  1133. 

  1134.         ff_h263_show_pict_info(s);

  1135.     if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){

  1136.         int i,j;

  1137.         for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));

  1138.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  1139.         for(i=0; i<13; i++){

  1140.             for(j=0; j<3; j++){

  1141.                 int v= get_bits(&s->gb, 8);

  1142.                 v |= get_sbits(&s->gb, 8)<<8;

  1143.                 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);

  1144.             }

  1145.             av_log(s->avctx, AV_LOG_DEBUG, "\n");

  1146.         }

  1147.         for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));

  1148.     }

  1149. 

  1150.     return 0;

  1151. }