## ffmpeg / libavcodec / ituh263dec.c @ ce5e49b0

History | View | Annotate | Download (35.7 KB)

1 | fc53b6af | Michael Niedermayer | ```
/*
``` |
---|---|---|---|

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 | ba87f080 | Diego Biurrun | ```
* @file
``` |

27 | fc53b6af | Michael Niedermayer | ```
* 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 | 301183d9 | Stefano Sabatini | s->qscale, av_get_picture_type_char(s->pict_type), |

75 | fc53b6af | Michael Niedermayer | ```
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 | 9ef5a9de | Luca Barbato | ```
av_dlog(s->avctx,"H.263+ UMV Motion = %d\n", code);
``` |

329 | fc53b6af | Michael Niedermayer | ```
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 | ce5e49b0 | Stefano Sabatini | assert(s->pict_type == AV_PICTURE_TYPE_P); |

351 | fc53b6af | Michael Niedermayer | |

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 | ce5e49b0 | Stefano Sabatini | if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) { |

464 | fc53b6af | Michael Niedermayer | ```
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 | 40d11227 | MÃ¥ns RullgÃ¥rd | ```
LOCAL_ALIGNED_16(DCTELEM, dblock, [64]);
``` |

567 | fc53b6af | Michael Niedermayer | ```
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 | ce5e49b0 | Stefano Sabatini | ```
if (s->pict_type == AV_PICTURE_TYPE_P) {
``` |

612 | fc53b6af | Michael Niedermayer | ```
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 | ce5e49b0 | Stefano Sabatini | } else if(s->pict_type==AV_PICTURE_TYPE_B) { |

704 | fc53b6af | Michael Niedermayer | ```
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 | ce5e49b0 | Stefano Sabatini | if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1) |

847 | fc53b6af | Michael Niedermayer | 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 | ce5e49b0 | Stefano Sabatini | s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb); |

925 | fc53b6af | Michael Niedermayer | |

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 | 9ef5a9de | Luca Barbato | ```
av_dlog(s->avctx, "ufep=1, format: %d\n", format);
``` |

955 | fc53b6af | Michael Niedermayer | 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 | ce5e49b0 | Stefano Sabatini | 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 | fc53b6af | Michael Niedermayer | ```
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 | 9ef5a9de | Luca Barbato | ```
av_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
``` |

1006 | fc53b6af | Michael Niedermayer | ```
/* 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 | 9ef5a9de | Luca Barbato | ```
av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
``` |

1019 | fc53b6af | Michael Niedermayer | ```
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 | ce5e49b0 | Stefano Sabatini | if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO")){ |

1116 | fc53b6af | Michael Niedermayer | ```
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 | } |