ffmpeg / libavcodec / ituh263dec.c @ ce5e49b0
History | View | Annotate | Download (35.7 KB)
| 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 DEBUG
|
| 31 |
#include <limits.h> |
| 32 |
|
| 33 |
#include "dsputil.h" |
| 34 |
#include "avcodec.h" |
| 35 |
#include "mpegvideo.h" |
| 36 |
#include "h263.h" |
| 37 |
#include "mathops.h" |
| 38 |
#include "unary.h" |
| 39 |
#include "flv.h" |
| 40 |
#include "mpeg4video.h" |
| 41 |
|
| 42 |
//#undef NDEBUG
|
| 43 |
//#include <assert.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 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 |
&mvtab[0][1], 2, 1, |
| 121 |
&mvtab[0][0], 2, 1, 538); |
| 122 |
init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
|
| 123 |
init_rl(&rl_intra_aic, ff_h263_static_rl_table_store[1]);
|
| 124 |
INIT_VLC_RL(ff_h263_rl_inter, 554);
|
| 125 |
INIT_VLC_RL(rl_intra_aic, 554);
|
| 126 |
INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
|
| 127 |
&h263_mbtype_b_tab[0][1], 2, 1, |
| 128 |
&h263_mbtype_b_tab[0][0], 2, 1, 80); |
| 129 |
INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
|
| 130 |
&cbpc_b_tab[0][1], 2, 1, |
| 131 |
&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 |
* decodes 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, gfid, 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 |
gfid = get_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 |
gfid = get_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 |
* finds 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(const uint8_t *restrict p, const uint8_t * restrict end) |
| 211 |
{
|
| 212 |
assert(p < end); |
| 213 |
|
| 214 |
end-=2;
|
| 215 |
p++; |
| 216 |
for(;p<end; p+=2){ |
| 217 |
if(!*p){
|
| 218 |
if (!p[-1] && p[1]) return p - 1; |
| 219 |
else if(!p[ 1] && p[2]) return p; |
| 220 |
} |
| 221 |
} |
| 222 |
return end+2; |
| 223 |
} |
| 224 |
|
| 225 |
/**
|
| 226 |
* decodes the group of blocks / video packet header.
|
| 227 |
* @return bit position of the resync_marker, or <0 if none was found
|
| 228 |
*/
|
| 229 |
int ff_h263_resync(MpegEncContext *s){
|
| 230 |
int left, pos, ret;
|
| 231 |
|
| 232 |
if(s->codec_id==CODEC_ID_MPEG4){
|
| 233 |
skip_bits1(&s->gb); |
| 234 |
align_get_bits(&s->gb); |
| 235 |
} |
| 236 |
|
| 237 |
if(show_bits(&s->gb, 16)==0){ |
| 238 |
pos= get_bits_count(&s->gb); |
| 239 |
if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4)
|
| 240 |
ret= mpeg4_decode_video_packet_header(s); |
| 241 |
else
|
| 242 |
ret= h263_decode_gob_header(s); |
| 243 |
if(ret>=0) |
| 244 |
return pos;
|
| 245 |
} |
| 246 |
//OK, it's not where it is supposed to be ...
|
| 247 |
s->gb= s->last_resync_gb; |
| 248 |
align_get_bits(&s->gb); |
| 249 |
left= get_bits_left(&s->gb); |
| 250 |
|
| 251 |
for(;left>16+1+5+5; left-=8){ |
| 252 |
if(show_bits(&s->gb, 16)==0){ |
| 253 |
GetBitContext bak= s->gb; |
| 254 |
|
| 255 |
pos= get_bits_count(&s->gb); |
| 256 |
if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4)
|
| 257 |
ret= mpeg4_decode_video_packet_header(s); |
| 258 |
else
|
| 259 |
ret= h263_decode_gob_header(s); |
| 260 |
if(ret>=0) |
| 261 |
return pos;
|
| 262 |
|
| 263 |
s->gb= bak; |
| 264 |
} |
| 265 |
skip_bits(&s->gb, 8);
|
| 266 |
} |
| 267 |
|
| 268 |
return -1; |
| 269 |
} |
| 270 |
|
| 271 |
int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
| 272 |
{
|
| 273 |
int code, val, sign, shift, l;
|
| 274 |
code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
|
| 275 |
|
| 276 |
if (code == 0) |
| 277 |
return pred;
|
| 278 |
if (code < 0) |
| 279 |
return 0xffff; |
| 280 |
|
| 281 |
sign = get_bits1(&s->gb); |
| 282 |
shift = f_code - 1;
|
| 283 |
val = code; |
| 284 |
if (shift) {
|
| 285 |
val = (val - 1) << shift;
|
| 286 |
val |= get_bits(&s->gb, shift); |
| 287 |
val++; |
| 288 |
} |
| 289 |
if (sign)
|
| 290 |
val = -val; |
| 291 |
val += pred; |
| 292 |
|
| 293 |
/* modulo decoding */
|
| 294 |
if (!s->h263_long_vectors) {
|
| 295 |
l = INT_BIT - 5 - f_code;
|
| 296 |
val = (val<<l)>>l; |
| 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 |
/* Decodes 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 |
assert(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= 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 = h263_decode_motion(s, pred_x, 1);
|
| 387 |
|
| 388 |
if (s->umvplus)
|
| 389 |
my = h263p_decode_umotion(s, pred_y); |
| 390 |
else
|
| 391 |
my = 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 = 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 = h263_decode_motion(s, pred_x, 1);
|
| 405 |
|
| 406 |
if (s->umvplus)
|
| 407 |
my = h263p_decode_umotion(s, pred_y); |
| 408 |
else
|
| 409 |
my = 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= 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, DCTELEM * 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 = &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 == 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 = 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->error_recognition >= FF_ER_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 == 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 = &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 |
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(DCTELEM, dblock, [64]);
|
| 567 |
int i, mbi;
|
| 568 |
|
| 569 |
/* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
|
| 570 |
* but real value should be restored in order to be used later (in OBMC condition)
|
| 571 |
*/
|
| 572 |
mbi = s->mb_intra; |
| 573 |
s->mb_intra = 0;
|
| 574 |
for (i = 0; i < 6; i++) { |
| 575 |
if (h263_decode_block(s, dblock, i, cbp&32) < 0) |
| 576 |
return -1; |
| 577 |
cbp+=cbp; |
| 578 |
} |
| 579 |
s->mb_intra = mbi; |
| 580 |
return 0; |
| 581 |
} |
| 582 |
|
| 583 |
static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb) |
| 584 |
{
|
| 585 |
int c, mv = 1; |
| 586 |
|
| 587 |
if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame |
| 588 |
c = get_bits1(gb); |
| 589 |
if (pb_frame == 2 && c) |
| 590 |
mv = !get_bits1(gb); |
| 591 |
} else { // h.263 Annex M improved PB-frame |
| 592 |
mv = get_unary(gb, 0, 4) + 1; |
| 593 |
c = mv & 1;
|
| 594 |
mv = !!(mv & 2);
|
| 595 |
} |
| 596 |
if(c)
|
| 597 |
*cbpb = get_bits(gb, 6);
|
| 598 |
return mv;
|
| 599 |
} |
| 600 |
|
| 601 |
int ff_h263_decode_mb(MpegEncContext *s,
|
| 602 |
DCTELEM block[6][64]) |
| 603 |
{
|
| 604 |
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
|
| 605 |
int16_t *mot_val; |
| 606 |
const int xy= s->mb_x + s->mb_y * s->mb_stride; |
| 607 |
int cbpb = 0, pb_mv_count = 0; |
| 608 |
|
| 609 |
assert(!s->h263_pred); |
| 610 |
|
| 611 |
if (s->pict_type == AV_PICTURE_TYPE_P) {
|
| 612 |
do{
|
| 613 |
if (get_bits1(&s->gb)) {
|
| 614 |
/* skip mb */
|
| 615 |
s->mb_intra = 0;
|
| 616 |
for(i=0;i<6;i++) |
| 617 |
s->block_last_index[i] = -1;
|
| 618 |
s->mv_dir = MV_DIR_FORWARD; |
| 619 |
s->mv_type = MV_TYPE_16X16; |
| 620 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
| 621 |
s->mv[0][0][0] = 0; |
| 622 |
s->mv[0][0][1] = 0; |
| 623 |
s->mb_skipped = !(s->obmc | s->loop_filter); |
| 624 |
goto end;
|
| 625 |
} |
| 626 |
cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
|
| 627 |
if (cbpc < 0){ |
| 628 |
av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 629 |
return -1; |
| 630 |
} |
| 631 |
}while(cbpc == 20); |
| 632 |
|
| 633 |
s->dsp.clear_blocks(s->block[0]);
|
| 634 |
|
| 635 |
dquant = cbpc & 8;
|
| 636 |
s->mb_intra = ((cbpc & 4) != 0); |
| 637 |
if (s->mb_intra) goto intra; |
| 638 |
|
| 639 |
if(s->pb_frame && get_bits1(&s->gb))
|
| 640 |
pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
| 641 |
cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
|
| 642 |
|
| 643 |
if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
| 644 |
cbpy ^= 0xF;
|
| 645 |
|
| 646 |
cbp = (cbpc & 3) | (cbpy << 2); |
| 647 |
if (dquant) {
|
| 648 |
h263_decode_dquant(s); |
| 649 |
} |
| 650 |
|
| 651 |
s->mv_dir = MV_DIR_FORWARD; |
| 652 |
if ((cbpc & 16) == 0) { |
| 653 |
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
| 654 |
/* 16x16 motion prediction */
|
| 655 |
s->mv_type = MV_TYPE_16X16; |
| 656 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 657 |
if (s->umvplus)
|
| 658 |
mx = h263p_decode_umotion(s, pred_x); |
| 659 |
else
|
| 660 |
mx = h263_decode_motion(s, pred_x, 1);
|
| 661 |
|
| 662 |
if (mx >= 0xffff) |
| 663 |
return -1; |
| 664 |
|
| 665 |
if (s->umvplus)
|
| 666 |
my = h263p_decode_umotion(s, pred_y); |
| 667 |
else
|
| 668 |
my = h263_decode_motion(s, pred_y, 1);
|
| 669 |
|
| 670 |
if (my >= 0xffff) |
| 671 |
return -1; |
| 672 |
s->mv[0][0][0] = mx; |
| 673 |
s->mv[0][0][1] = my; |
| 674 |
|
| 675 |
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
| 676 |
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
|
| 677 |
} else {
|
| 678 |
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
| 679 |
s->mv_type = MV_TYPE_8X8; |
| 680 |
for(i=0;i<4;i++) { |
| 681 |
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
|
| 682 |
if (s->umvplus)
|
| 683 |
mx = h263p_decode_umotion(s, pred_x); |
| 684 |
else
|
| 685 |
mx = h263_decode_motion(s, pred_x, 1);
|
| 686 |
if (mx >= 0xffff) |
| 687 |
return -1; |
| 688 |
|
| 689 |
if (s->umvplus)
|
| 690 |
my = h263p_decode_umotion(s, pred_y); |
| 691 |
else
|
| 692 |
my = h263_decode_motion(s, pred_y, 1);
|
| 693 |
if (my >= 0xffff) |
| 694 |
return -1; |
| 695 |
s->mv[0][i][0] = mx; |
| 696 |
s->mv[0][i][1] = my; |
| 697 |
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
| 698 |
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
|
| 699 |
mot_val[0] = mx;
|
| 700 |
mot_val[1] = my;
|
| 701 |
} |
| 702 |
} |
| 703 |
} else if(s->pict_type==AV_PICTURE_TYPE_B) { |
| 704 |
int mb_type;
|
| 705 |
const int stride= s->b8_stride; |
| 706 |
int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; |
| 707 |
int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; |
| 708 |
// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
|
| 709 |
|
| 710 |
//FIXME ugly
|
| 711 |
mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= |
| 712 |
mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= |
| 713 |
mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= |
| 714 |
mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; |
| 715 |
|
| 716 |
do{
|
| 717 |
mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
|
| 718 |
if (mb_type < 0){ |
| 719 |
av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 720 |
return -1; |
| 721 |
} |
| 722 |
|
| 723 |
mb_type= h263_mb_type_b_map[ mb_type ]; |
| 724 |
}while(!mb_type);
|
| 725 |
|
| 726 |
s->mb_intra = IS_INTRA(mb_type); |
| 727 |
if(HAS_CBP(mb_type)){
|
| 728 |
s->dsp.clear_blocks(s->block[0]);
|
| 729 |
cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
|
| 730 |
if(s->mb_intra){
|
| 731 |
dquant = IS_QUANT(mb_type); |
| 732 |
goto intra;
|
| 733 |
} |
| 734 |
|
| 735 |
cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
|
| 736 |
|
| 737 |
if (cbpy < 0){ |
| 738 |
av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 739 |
return -1; |
| 740 |
} |
| 741 |
|
| 742 |
if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
| 743 |
cbpy ^= 0xF;
|
| 744 |
|
| 745 |
cbp = (cbpc & 3) | (cbpy << 2); |
| 746 |
}else
|
| 747 |
cbp=0;
|
| 748 |
|
| 749 |
assert(!s->mb_intra); |
| 750 |
|
| 751 |
if(IS_QUANT(mb_type)){
|
| 752 |
h263_decode_dquant(s); |
| 753 |
} |
| 754 |
|
| 755 |
if(IS_DIRECT(mb_type)){
|
| 756 |
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
| 757 |
mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); |
| 758 |
}else{
|
| 759 |
s->mv_dir = 0;
|
| 760 |
s->mv_type= MV_TYPE_16X16; |
| 761 |
//FIXME UMV
|
| 762 |
|
| 763 |
if(USES_LIST(mb_type, 0)){ |
| 764 |
int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); |
| 765 |
s->mv_dir = MV_DIR_FORWARD; |
| 766 |
|
| 767 |
mx = h263_decode_motion(s, mx, 1);
|
| 768 |
my = h263_decode_motion(s, my, 1);
|
| 769 |
|
| 770 |
s->mv[0][0][0] = mx; |
| 771 |
s->mv[0][0][1] = my; |
| 772 |
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
| 773 |
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; |
| 774 |
} |
| 775 |
|
| 776 |
if(USES_LIST(mb_type, 1)){ |
| 777 |
int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); |
| 778 |
s->mv_dir |= MV_DIR_BACKWARD; |
| 779 |
|
| 780 |
mx = h263_decode_motion(s, mx, 1);
|
| 781 |
my = h263_decode_motion(s, my, 1);
|
| 782 |
|
| 783 |
s->mv[1][0][0] = mx; |
| 784 |
s->mv[1][0][1] = my; |
| 785 |
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
| 786 |
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; |
| 787 |
} |
| 788 |
} |
| 789 |
|
| 790 |
s->current_picture.mb_type[xy]= mb_type; |
| 791 |
} else { /* I-Frame */ |
| 792 |
do{
|
| 793 |
cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
|
| 794 |
if (cbpc < 0){ |
| 795 |
av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 796 |
return -1; |
| 797 |
} |
| 798 |
}while(cbpc == 8); |
| 799 |
|
| 800 |
s->dsp.clear_blocks(s->block[0]);
|
| 801 |
|
| 802 |
dquant = cbpc & 4;
|
| 803 |
s->mb_intra = 1;
|
| 804 |
intra:
|
| 805 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
| 806 |
if (s->h263_aic) {
|
| 807 |
s->ac_pred = get_bits1(&s->gb); |
| 808 |
if(s->ac_pred){
|
| 809 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
| 810 |
|
| 811 |
s->h263_aic_dir = get_bits1(&s->gb); |
| 812 |
} |
| 813 |
}else
|
| 814 |
s->ac_pred = 0;
|
| 815 |
|
| 816 |
if(s->pb_frame && get_bits1(&s->gb))
|
| 817 |
pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
| 818 |
cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
|
| 819 |
if(cbpy<0){ |
| 820 |
av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 821 |
return -1; |
| 822 |
} |
| 823 |
cbp = (cbpc & 3) | (cbpy << 2); |
| 824 |
if (dquant) {
|
| 825 |
h263_decode_dquant(s); |
| 826 |
} |
| 827 |
|
| 828 |
pb_mv_count += !!s->pb_frame; |
| 829 |
} |
| 830 |
|
| 831 |
while(pb_mv_count--){
|
| 832 |
h263_decode_motion(s, 0, 1); |
| 833 |
h263_decode_motion(s, 0, 1); |
| 834 |
} |
| 835 |
|
| 836 |
/* decode each block */
|
| 837 |
for (i = 0; i < 6; i++) { |
| 838 |
if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
| 839 |
return -1; |
| 840 |
cbp+=cbp; |
| 841 |
} |
| 842 |
|
| 843 |
if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) |
| 844 |
return -1; |
| 845 |
if(s->obmc && !s->mb_intra){
|
| 846 |
if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1) |
| 847 |
preview_obmc(s); |
| 848 |
} |
| 849 |
end:
|
| 850 |
|
| 851 |
/* per-MB end of slice check */
|
| 852 |
{
|
| 853 |
int v= show_bits(&s->gb, 16); |
| 854 |
|
| 855 |
if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ |
| 856 |
v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
|
| 857 |
} |
| 858 |
|
| 859 |
if(v==0) |
| 860 |
return SLICE_END;
|
| 861 |
} |
| 862 |
|
| 863 |
return SLICE_OK;
|
| 864 |
} |
| 865 |
|
| 866 |
/* most is hardcoded. should extend to handle all h263 streams */
|
| 867 |
int h263_decode_picture_header(MpegEncContext *s)
|
| 868 |
{
|
| 869 |
int format, width, height, i;
|
| 870 |
uint32_t startcode; |
| 871 |
|
| 872 |
align_get_bits(&s->gb); |
| 873 |
|
| 874 |
startcode= get_bits(&s->gb, 22-8); |
| 875 |
|
| 876 |
for(i= get_bits_left(&s->gb); i>24; i-=8) { |
| 877 |
startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
| 878 |
|
| 879 |
if(startcode == 0x20) |
| 880 |
break;
|
| 881 |
} |
| 882 |
|
| 883 |
if (startcode != 0x20) { |
| 884 |
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
|
| 885 |
return -1; |
| 886 |
} |
| 887 |
/* temporal reference */
|
| 888 |
i = get_bits(&s->gb, 8); /* picture timestamp */ |
| 889 |
if( (s->picture_number&~0xFF)+i < s->picture_number) |
| 890 |
i+= 256;
|
| 891 |
s->current_picture_ptr->pts= |
| 892 |
s->picture_number= (s->picture_number&~0xFF) + i;
|
| 893 |
|
| 894 |
/* PTYPE starts here */
|
| 895 |
if (get_bits1(&s->gb) != 1) { |
| 896 |
/* marker */
|
| 897 |
av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
|
| 898 |
return -1; |
| 899 |
} |
| 900 |
if (get_bits1(&s->gb) != 0) { |
| 901 |
av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
|
| 902 |
return -1; /* h263 id */ |
| 903 |
} |
| 904 |
skip_bits1(&s->gb); /* split screen off */
|
| 905 |
skip_bits1(&s->gb); /* camera off */
|
| 906 |
skip_bits1(&s->gb); /* freeze picture release off */
|
| 907 |
|
| 908 |
format = get_bits(&s->gb, 3);
|
| 909 |
/*
|
| 910 |
0 forbidden
|
| 911 |
1 sub-QCIF
|
| 912 |
10 QCIF
|
| 913 |
7 extended PTYPE (PLUSPTYPE)
|
| 914 |
*/
|
| 915 |
|
| 916 |
if (format != 7 && format != 6) { |
| 917 |
s->h263_plus = 0;
|
| 918 |
/* H.263v1 */
|
| 919 |
width = h263_format[format][0];
|
| 920 |
height = h263_format[format][1];
|
| 921 |
if (!width)
|
| 922 |
return -1; |
| 923 |
|
| 924 |
s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb); |
| 925 |
|
| 926 |
s->h263_long_vectors = get_bits1(&s->gb); |
| 927 |
|
| 928 |
if (get_bits1(&s->gb) != 0) { |
| 929 |
av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
|
| 930 |
return -1; /* SAC: off */ |
| 931 |
} |
| 932 |
s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
|
| 933 |
s->unrestricted_mv = s->h263_long_vectors || s->obmc; |
| 934 |
|
| 935 |
s->pb_frame = get_bits1(&s->gb); |
| 936 |
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
|
| 937 |
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
|
| 938 |
|
| 939 |
s->width = width; |
| 940 |
s->height = height; |
| 941 |
s->avctx->sample_aspect_ratio= (AVRational){12,11};
|
| 942 |
s->avctx->time_base= (AVRational){1001, 30000};
|
| 943 |
} else {
|
| 944 |
int ufep;
|
| 945 |
|
| 946 |
/* H.263v2 */
|
| 947 |
s->h263_plus = 1;
|
| 948 |
ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ |
| 949 |
|
| 950 |
/* ufep other than 0 and 1 are reserved */
|
| 951 |
if (ufep == 1) { |
| 952 |
/* OPPTYPE */
|
| 953 |
format = get_bits(&s->gb, 3);
|
| 954 |
av_dlog(s->avctx, "ufep=1, format: %d\n", format);
|
| 955 |
s->custom_pcf= get_bits1(&s->gb); |
| 956 |
s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
|
| 957 |
if (get_bits1(&s->gb) != 0) { |
| 958 |
av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
|
| 959 |
} |
| 960 |
s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
|
| 961 |
s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
|
| 962 |
s->loop_filter= get_bits1(&s->gb); |
| 963 |
s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; |
| 964 |
|
| 965 |
s->h263_slice_structured= get_bits1(&s->gb); |
| 966 |
if (get_bits1(&s->gb) != 0) { |
| 967 |
av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
|
| 968 |
} |
| 969 |
if (get_bits1(&s->gb) != 0) { |
| 970 |
av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
|
| 971 |
} |
| 972 |
s->alt_inter_vlc= get_bits1(&s->gb); |
| 973 |
s->modified_quant= get_bits1(&s->gb); |
| 974 |
if(s->modified_quant)
|
| 975 |
s->chroma_qscale_table= ff_h263_chroma_qscale_table; |
| 976 |
|
| 977 |
skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
| 978 |
|
| 979 |
skip_bits(&s->gb, 3); /* Reserved */ |
| 980 |
} else if (ufep != 0) { |
| 981 |
av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
|
| 982 |
return -1; |
| 983 |
} |
| 984 |
|
| 985 |
/* MPPTYPE */
|
| 986 |
s->pict_type = get_bits(&s->gb, 3);
|
| 987 |
switch(s->pict_type){
|
| 988 |
case 0: s->pict_type= AV_PICTURE_TYPE_I;break; |
| 989 |
case 1: s->pict_type= AV_PICTURE_TYPE_P;break; |
| 990 |
case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break; |
| 991 |
case 3: s->pict_type= AV_PICTURE_TYPE_B;break; |
| 992 |
case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO |
| 993 |
default:
|
| 994 |
return -1; |
| 995 |
} |
| 996 |
skip_bits(&s->gb, 2);
|
| 997 |
s->no_rounding = get_bits1(&s->gb); |
| 998 |
skip_bits(&s->gb, 4);
|
| 999 |
|
| 1000 |
/* Get the picture dimensions */
|
| 1001 |
if (ufep) {
|
| 1002 |
if (format == 6) { |
| 1003 |
/* Custom Picture Format (CPFMT) */
|
| 1004 |
s->aspect_ratio_info = get_bits(&s->gb, 4);
|
| 1005 |
av_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
|
| 1006 |
/* aspect ratios:
|
| 1007 |
0 - forbidden
|
| 1008 |
1 - 1:1
|
| 1009 |
2 - 12:11 (CIF 4:3)
|
| 1010 |
3 - 10:11 (525-type 4:3)
|
| 1011 |
4 - 16:11 (CIF 16:9)
|
| 1012 |
5 - 40:33 (525-type 16:9)
|
| 1013 |
6-14 - reserved
|
| 1014 |
*/
|
| 1015 |
width = (get_bits(&s->gb, 9) + 1) * 4; |
| 1016 |
skip_bits1(&s->gb); |
| 1017 |
height = get_bits(&s->gb, 9) * 4; |
| 1018 |
av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
|
| 1019 |
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
|
| 1020 |
/* aspected dimensions */
|
| 1021 |
s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
|
| 1022 |
s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
|
| 1023 |
}else{
|
| 1024 |
s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info]; |
| 1025 |
} |
| 1026 |
} else {
|
| 1027 |
width = h263_format[format][0];
|
| 1028 |
height = h263_format[format][1];
|
| 1029 |
s->avctx->sample_aspect_ratio= (AVRational){12,11};
|
| 1030 |
} |
| 1031 |
if ((width == 0) || (height == 0)) |
| 1032 |
return -1; |
| 1033 |
s->width = width; |
| 1034 |
s->height = height; |
| 1035 |
|
| 1036 |
if(s->custom_pcf){
|
| 1037 |
int gcd;
|
| 1038 |
s->avctx->time_base.den= 1800000;
|
| 1039 |
s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
|
| 1040 |
s->avctx->time_base.num*= get_bits(&s->gb, 7);
|
| 1041 |
if(s->avctx->time_base.num == 0){ |
| 1042 |
av_log(s, AV_LOG_ERROR, "zero framerate\n");
|
| 1043 |
return -1; |
| 1044 |
} |
| 1045 |
gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); |
| 1046 |
s->avctx->time_base.den /= gcd; |
| 1047 |
s->avctx->time_base.num /= gcd; |
| 1048 |
}else{
|
| 1049 |
s->avctx->time_base= (AVRational){1001, 30000};
|
| 1050 |
} |
| 1051 |
} |
| 1052 |
|
| 1053 |
if(s->custom_pcf){
|
| 1054 |
skip_bits(&s->gb, 2); //extended Temporal reference |
| 1055 |
} |
| 1056 |
|
| 1057 |
if (ufep) {
|
| 1058 |
if (s->umvplus) {
|
| 1059 |
if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
| 1060 |
skip_bits1(&s->gb); |
| 1061 |
} |
| 1062 |
if(s->h263_slice_structured){
|
| 1063 |
if (get_bits1(&s->gb) != 0) { |
| 1064 |
av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
|
| 1065 |
} |
| 1066 |
if (get_bits1(&s->gb) != 0) { |
| 1067 |
av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
|
| 1068 |
} |
| 1069 |
} |
| 1070 |
} |
| 1071 |
|
| 1072 |
s->qscale = get_bits(&s->gb, 5);
|
| 1073 |
} |
| 1074 |
|
| 1075 |
s->mb_width = (s->width + 15) / 16; |
| 1076 |
s->mb_height = (s->height + 15) / 16; |
| 1077 |
s->mb_num = s->mb_width * s->mb_height; |
| 1078 |
|
| 1079 |
if (s->pb_frame) {
|
| 1080 |
skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ |
| 1081 |
if (s->custom_pcf)
|
| 1082 |
skip_bits(&s->gb, 2); //extended Temporal reference |
| 1083 |
skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ |
| 1084 |
} |
| 1085 |
|
| 1086 |
/* PEI */
|
| 1087 |
while (get_bits1(&s->gb) != 0) { |
| 1088 |
skip_bits(&s->gb, 8);
|
| 1089 |
} |
| 1090 |
|
| 1091 |
if(s->h263_slice_structured){
|
| 1092 |
if (get_bits1(&s->gb) != 1) { |
| 1093 |
av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
|
| 1094 |
return -1; |
| 1095 |
} |
| 1096 |
|
| 1097 |
ff_h263_decode_mba(s); |
| 1098 |
|
| 1099 |
if (get_bits1(&s->gb) != 1) { |
| 1100 |
av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
|
| 1101 |
return -1; |
| 1102 |
} |
| 1103 |
} |
| 1104 |
s->f_code = 1;
|
| 1105 |
|
| 1106 |
if(s->h263_aic){
|
| 1107 |
s->y_dc_scale_table= |
| 1108 |
s->c_dc_scale_table= ff_aic_dc_scale_table; |
| 1109 |
}else{
|
| 1110 |
s->y_dc_scale_table= |
| 1111 |
s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
| 1112 |
} |
| 1113 |
|
| 1114 |
ff_h263_show_pict_info(s); |
| 1115 |
if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO")){ |
| 1116 |
int i,j;
|
| 1117 |
for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
| 1118 |
av_log(s->avctx, AV_LOG_DEBUG, "\n");
|
| 1119 |
for(i=0; i<13; i++){ |
| 1120 |
for(j=0; j<3; j++){ |
| 1121 |
int v= get_bits(&s->gb, 8); |
| 1122 |
v |= get_sbits(&s->gb, 8)<<8; |
| 1123 |
av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
|
| 1124 |
} |
| 1125 |
av_log(s->avctx, AV_LOG_DEBUG, "\n");
|
| 1126 |
} |
| 1127 |
for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
| 1128 |
} |
| 1129 |
|
| 1130 |
return 0; |
| 1131 |
} |