FFmpeg: libavcodec/rv10.c Source File

FFmpeg

[フレーム]

libavcodec

rv10.c

Go to the documentation of this file.

1 /*

2 * RV10/RV20 decoder

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 /**

24 * @file

25 * RV10/RV20 decoder

26 */

28 #include <inttypes.h>

30 #include "libavutil/imgutils.h"

31 #include "libavutil/thread.h"

33 #include "avcodec.h"

34 #include "codec_internal.h"

35 #include "decode.h"

36 #include "error_resilience.h"

37 #include "h263.h"

38 #include "h263data.h"

39 #include "h263dec.h"

40 #include "mpeg_er.h"

41 #include "mpegvideo.h"

42 #include "mpegvideodec.h"

43 #include "mpeg4video.h"

44 #include "mpegvideodata.h"

45 #include "rv10dec.h"

47 #define RV_GET_MAJOR_VER(x) ((x) >> 28)

48 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)

49 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)

51 #define MAX_VLC_ENTRIES 1023 // Note: Does not include the skip entries.

52 #define DC_VLC_BITS 9

54 typedef struct RVDecContext {

55 H263DecContext h;

56 int sub_id;

57 int orig_width, orig_height;

58 } RVDecContext;

60 /* (run, length) encoded value for the symbols table. The actual symbols

61 * are run..run - length (mod 256).

62 * The last two entries in the following table apply to luma only.

63 * The skip values are not included in this list. */

64 static const uint8_t rv_sym_run_len[][2] = {

65 { 0, 0 }, { 1, 0 }, { 255, 0 }, { 3, 1 }, { 254, 1 },

66 { 7, 3 }, { 252, 3 }, { 15, 7 }, { 248, 7 }, { 31, 15 },

67 { 240, 15 }, { 63, 31 }, { 224, 31 }, { 127, 63 }, { 192, 63 },

68 { 255, 127 }, { 128, 127 }, { 127, 255 }, { 128, 255 },

69 };

71 /* entry[i] of the following tables gives

72 * the number of VLC codes of length i + 2. */

73 static const uint16_t rv_lum_len_count[15] = {

74 1, 0, 2, 4, 8, 16, 32, 0, 64, 0, 128, 0, 256, 0, 512,

75 };

77 static const uint16_t rv_chrom_len_count[15] = {

78 1, 2, 4, 0, 8, 0, 16, 0, 32, 0, 64, 0, 128, 0, 256,

79 };

81 static VLCElem rv_dc_lum[1472], rv_dc_chrom[992];

83 int ff_rv_decode_dc(H263DecContext *const h, int n)

84 {

85 int code;

87 if (n < 4) {

88 code = get_vlc2(&h->gb, rv_dc_lum, DC_VLC_BITS, 2);

89 } else {

90 code = get_vlc2(&h->gb, rv_dc_chrom, DC_VLC_BITS, 2);

91 if (code < 0) {

92 av_log(h->c.avctx, AV_LOG_ERROR, "chroma dc error\n");

93 return -1;

94 }

95 }

96 return code;

97 }

99 /* read RV 1.0 compatible frame header */

100 static int rv10_decode_picture_header(H263DecContext *const h)

101 {

102 int mb_count, pb_frame, marker, mb_xy;

103

104 marker = get_bits1(&h->gb);

105

106 if (get_bits1(&h->gb))

107 h->c.pict_type = AV_PICTURE_TYPE_P;

108 else

109 h->c.pict_type = AV_PICTURE_TYPE_I;

110

111 if (!marker)

112 av_log(h->c.avctx, AV_LOG_ERROR, "marker missing\n");

113

114 pb_frame = get_bits1(&h->gb);

115

116 ff_dlog(h->c.avctx, "pict_type=%d pb_frame=%d\n", h->c.pict_type, pb_frame);

117

118 if (pb_frame) {

119 avpriv_request_sample(h->c.avctx, "PB-frame");

120 return AVERROR_PATCHWELCOME;

121 }

122

123 h->c.qscale = get_bits(&h->gb, 5);

124 if (h->c.qscale == 0) {

125 av_log(h->c.avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");

126 return AVERROR_INVALIDDATA;

127 }

128

129 if (h->c.pict_type == AV_PICTURE_TYPE_I) {

130 if (h->rv10_version == 3) {

131 /* specific MPEG like DC coding not used */

132 h->c.last_dc[0] = get_bits(&h->gb, 8);

133 h->c.last_dc[1] = get_bits(&h->gb, 8);

134 h->c.last_dc[2] = get_bits(&h->gb, 8);

135 ff_dlog(h->c.avctx, "DC:%d %d %d\n", h->c.last_dc[0],

136 h->c.last_dc[1], h->c.last_dc[2]);

137 }

138 }

139 /* if multiple packets per frame are sent, the position at which

140 * to display the macroblocks is coded here */

141

142 mb_xy = h->c.mb_x + h->c.mb_y * h->c.mb_width;

143 if (show_bits(&h->gb, 12) == 0 || (mb_xy && mb_xy < h->c.mb_num)) {

144 h->c.mb_x = get_bits(&h->gb, 6); /* mb_x */

145 h->c.mb_y = get_bits(&h->gb, 6); /* mb_y */

146 mb_count = get_bits(&h->gb, 12);

147 } else {

148 h->c.mb_x = 0;

149 h->c.mb_y = 0;

150 mb_count = h->c.mb_width * h->c.mb_height;

151 }

152 skip_bits(&h->gb, 3); /* ignored */

153

154 return mb_count;

155 }

156

157 static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)

158 {

159 static const enum AVPictureType pict_types[] =

160 { AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_I /* hmm ... */,

161 AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B };

162 H263DecContext *const h = &rv->h;

163 int seq, mb_pos, ret;

164 int rpr_max;

165

166 h->c.pict_type = pict_types[get_bits(&h->gb, 2)];

167

168 if (h->c.low_delay && h->c.pict_type == AV_PICTURE_TYPE_B) {

169 av_log(h->c.avctx, AV_LOG_ERROR, "low delay B\n");

170 return -1;

171 }

172 if (!h->c.last_pic.ptr && h->c.pict_type == AV_PICTURE_TYPE_B) {

173 av_log(h->c.avctx, AV_LOG_ERROR, "early B-frame\n");

174 return AVERROR_INVALIDDATA;

175 }

176

177 if (get_bits1(&h->gb)) {

178 av_log(h->c.avctx, AV_LOG_ERROR, "reserved bit set\n");

179 return AVERROR_INVALIDDATA;

180 }

181

182 h->c.qscale = get_bits(&h->gb, 5);

183 if (h->c.qscale == 0) {

184 av_log(h->c.avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");

185 return AVERROR_INVALIDDATA;

186 }

187

188 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)

189 h->loop_filter = get_bits1(&h->gb) && !h->c.avctx->lowres;

190

191 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)

192 seq = get_bits(&h->gb, 8) << 7;

193 else

194 seq = get_bits(&h->gb, 13) << 2;

195

196 rpr_max = h->c.avctx->extradata[1] & 7;

197 if (rpr_max) {

198 int f, new_w, new_h;

199 int rpr_bits = av_log2(rpr_max) + 1;

200

201 f = get_bits(&h->gb, rpr_bits);

202

203 if (f) {

204 if (h->c.avctx->extradata_size < 8 + 2 * f) {

205 av_log(h->c.avctx, AV_LOG_ERROR, "Extradata too small.\n");

206 return AVERROR_INVALIDDATA;

207 }

208

209 new_w = 4 * h->c.avctx->extradata[6 + 2 * f];

210 new_h = 4 * h->c.avctx->extradata[7 + 2 * f];

211 } else {

212 new_w = rv->orig_width;

213 new_h = rv->orig_height;

214 }

215 if (new_w != h->c.width || new_h != h->c.height || !h->c.context_initialized) {

216 AVRational old_aspect = h->c.avctx->sample_aspect_ratio;

217 av_log(h->c.avctx, AV_LOG_DEBUG,

218 "attempting to change resolution to %dx%d\n", new_w, new_h);

219 if (av_image_check_size(new_w, new_h, 0, h->c.avctx) < 0)

220 return AVERROR_INVALIDDATA;

221

222 if (whole_size < (new_w + 15)/16 * ((new_h + 15)/16) / 8)

223 return AVERROR_INVALIDDATA;

224

225 ff_mpv_common_end(&h->c);

226

227 // attempt to keep aspect during typical resolution switches

228 if (!old_aspect.num)

229 old_aspect = (AVRational){1, 1};

230 if (2 * (int64_t)new_w * h->c.height == (int64_t)new_h * h->c.width)

231 h->c.avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});

232 if ((int64_t)new_w * h->c.height == 2 * (int64_t)new_h * h->c.width)

233 h->c.avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});

234

235 ret = ff_set_dimensions(h->c.avctx, new_w, new_h);

236 if (ret < 0)

237 return ret;

238

239 h->c.width = new_w;

240 h->c.height = new_h;

241 if ((ret = ff_mpv_common_init(&h->c)) < 0)

242 return ret;

243 }

244

245 if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) {

246 av_log(h->c.avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);

247 }

248 }

249 if (av_image_check_size(h->c.width, h->c.height, 0, h->c.avctx) < 0)

250 return AVERROR_INVALIDDATA;

251

252 mb_pos = ff_h263_decode_mba(h);

253

254 seq |= h->c.time & ~0x7FFF;

255 if (seq - h->c.time > 0x4000)

256 seq -= 0x8000;

257 if (seq - h->c.time < -0x4000)

258 seq += 0x8000;

259

260 if (seq != h->c.time) {

261 if (h->c.pict_type != AV_PICTURE_TYPE_B) {

262 h->c.time = seq;

263 h->c.pp_time = h->c.time - h->c.last_non_b_time;

264 h->c.last_non_b_time = h->c.time;

265 } else {

266 h->c.time = seq;

267 h->c.pb_time = h->c.pp_time - (h->c.last_non_b_time - h->c.time);

268 }

269 }

270 if (h->c.pict_type == AV_PICTURE_TYPE_B) {

271 if (h->c.pp_time <=h->c.pb_time || h->c.pp_time <= h->c.pp_time - h->c.pb_time || h->c.pp_time<=0) {

272 av_log(h->c.avctx, AV_LOG_DEBUG,

273 "messed up order, possible from seeking? skipping current B-frame\n");

274 #define ERROR_SKIP_FRAME -123

275 return ERROR_SKIP_FRAME;

276 }

277 ff_mpeg4_init_direct_mv(&h->c);

278 }

279

280 h->c.no_rounding = get_bits1(&h->gb);

281

282 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && h->c.pict_type == AV_PICTURE_TYPE_B)

283 // binary decoder reads 3+2 bits here but they don't seem to be used

284 skip_bits(&h->gb, 5);

285

286 h->c.h263_aic = h->c.pict_type == AV_PICTURE_TYPE_I;

287 if (h->c.h263_aic) {

288 h->c.y_dc_scale_table =

289 h->c.c_dc_scale_table = ff_aic_dc_scale_table;

290 } else {

291 h->c.y_dc_scale_table =

292 h->c.c_dc_scale_table = ff_mpeg1_dc_scale_table;

293 }

294 if (!h->c.avctx->lowres)

295 h->loop_filter = 1;

296

297 if (h->c.avctx->debug & FF_DEBUG_PICT_INFO) {

298 av_log(h->c.avctx, AV_LOG_INFO,

299 "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",

300 seq, h->c.mb_x, h->c.mb_y, h->c.pict_type, h->c.qscale,

301 h->c.no_rounding);

302 }

303

304 av_assert0(h->c.pict_type != AV_PICTURE_TYPE_B || !h->c.low_delay);

305

306 return h->c.mb_width * h->c.mb_height - mb_pos;

307 }

308

309 static av_cold void rv10_build_vlc(VLCElem vlc[], int table_size,

310 const uint16_t len_count[15],

311 const uint8_t sym_rl[][2], int sym_rl_elems)

312 {

313 uint16_t syms[MAX_VLC_ENTRIES];

314 uint8_t lens[MAX_VLC_ENTRIES];

315 unsigned nb_syms = 0, nb_lens = 0;

316

317 for (unsigned i = 0; i < sym_rl_elems; i++) {

318 unsigned cur_sym = sym_rl[i][0];

319 for (unsigned tmp = nb_syms + sym_rl[i][1]; nb_syms <= tmp; nb_syms++)

320 syms[nb_syms] = 0xFF & cur_sym--;

321 }

322

323 for (unsigned i = 0; i < 15; i++)

324 for (unsigned tmp = nb_lens + len_count[i]; nb_lens < tmp; nb_lens++)

325 lens[nb_lens] = i + 2;

326 av_assert1(nb_lens == nb_syms);

327 ff_vlc_init_table_from_lengths(vlc, table_size, DC_VLC_BITS, nb_lens,

328 lens, 1, syms, 2, 2, 0, 0);

329 }

330

331 static av_cold void rv10_init_static(void)

332 {

333 rv10_build_vlc(rv_dc_lum, FF_ARRAY_ELEMS(rv_dc_lum), rv_lum_len_count,

334 rv_sym_run_len, FF_ARRAY_ELEMS(rv_sym_run_len));

335 for (int i = 0; i < 1 << (DC_VLC_BITS - 7 /* Length of skip prefix */); i++) {

336 /* All codes beginning with 0x7F have the same length and value.

337 * Modifying the table directly saves us the useless subtables. */

338 rv_dc_lum[(0x7F << (DC_VLC_BITS - 7)) + i].sym = 255;

339 rv_dc_lum[(0x7F << (DC_VLC_BITS - 7)) + i].len = 18;

340 }

341 rv10_build_vlc(rv_dc_chrom, FF_ARRAY_ELEMS(rv_dc_chrom), rv_chrom_len_count,

342 rv_sym_run_len, FF_ARRAY_ELEMS(rv_sym_run_len) - 2);

343 for (int i = 0; i < 1 << (DC_VLC_BITS - 9 /* Length of skip prefix */); i++) {

344 /* Same as above. */

345 rv_dc_chrom[(0x1FE << (DC_VLC_BITS - 9)) + i].sym = 255;

346 rv_dc_chrom[(0x1FE << (DC_VLC_BITS - 9)) + i].len = 18;

347 }

348 }

349

350 static av_cold int rv10_decode_init(AVCodecContext *avctx)

351 {

352 static AVOnce init_static_once = AV_ONCE_INIT;

353 RVDecContext *rv = avctx->priv_data;

354 H263DecContext *const h = &rv->h;

355 int major_ver, minor_ver, micro_ver, ret;

356

357 if (avctx->extradata_size < 8) {

358 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");

359 return AVERROR_INVALIDDATA;

360 }

361 if ((ret = av_image_check_size(avctx->coded_width,

362 avctx->coded_height, 0, avctx)) < 0)

363 return ret;

364

365 ret = ff_h263_decode_init(avctx);

366 if (ret < 0)

367 return ret;

368

369 rv->orig_width = avctx->coded_width;

370 rv->orig_height = avctx->coded_height;

371

372 h->h263_long_vectors = avctx->extradata[3] & 1;

373 rv->sub_id = AV_RB32A(avctx->extradata + 4);

374 if (avctx->codec_id == AV_CODEC_ID_RV20) {

375 h->modified_quant = 1;

376 h->c.chroma_qscale_table = ff_h263_chroma_qscale_table;

377 }

378

379 major_ver = RV_GET_MAJOR_VER(rv->sub_id);

380 minor_ver = RV_GET_MINOR_VER(rv->sub_id);

381 micro_ver = RV_GET_MICRO_VER(rv->sub_id);

382

383 switch (major_ver) {

384 case 1:

385 h->rv10_version = micro_ver ? 3 : 1;

386 h->c.obmc = micro_ver == 2;

387 break;

388 case 2:

389 if (minor_ver >= 2) {

390 h->c.low_delay = 0;

391 avctx->has_b_frames = 1;

392 }

393 break;

394 default:

395 av_log(avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);

396 avpriv_request_sample(avctx, "RV1/2 version");

397 return AVERROR_PATCHWELCOME;

398 }

399

400 if (avctx->debug & FF_DEBUG_PICT_INFO) {

401 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%"PRIX32"\n", rv->sub_id,

402 AV_RL32A(avctx->extradata));

403 }

404

405 /* init static VLCs */

406 ff_thread_once(&init_static_once, rv10_init_static);

407

408 return 0;

409 }

410

411 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,

412 int buf_size, int buf_size2, int whole_size)

413 {

414 RVDecContext *rv = avctx->priv_data;

415 H263DecContext *const h = &rv->h;

416 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;

417

418 active_bits_size = buf_size * 8;

419 init_get_bits(&h->gb, buf, FFMAX(buf_size, buf_size2) * 8);

420 if (h->c.codec_id == AV_CODEC_ID_RV10)

421 mb_count = rv10_decode_picture_header(h);

422 else

423 mb_count = rv20_decode_picture_header(rv, whole_size);

424 if (mb_count < 0) {

425 if (mb_count != ERROR_SKIP_FRAME)

426 av_log(h->c.avctx, AV_LOG_ERROR, "HEADER ERROR\n");

427 return AVERROR_INVALIDDATA;

428 }

429

430 if (h->c.mb_x >= h->c.mb_width ||

431 h->c.mb_y >= h->c.mb_height) {

432 av_log(h->c.avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", h->c.mb_x, h->c.mb_y);

433 return AVERROR_INVALIDDATA;

434 }

435 mb_pos = h->c.mb_y * h->c.mb_width + h->c.mb_x;

436 left = h->c.mb_width * h->c.mb_height - mb_pos;

437 if (mb_count > left) {

438 av_log(h->c.avctx, AV_LOG_ERROR, "COUNT ERROR\n");

439 return AVERROR_INVALIDDATA;

440 }

441

442 if (whole_size < h->c.mb_width * h->c.mb_height / 8)

443 return AVERROR_INVALIDDATA;

444

445 if ((h->c.mb_x == 0 && h->c.mb_y == 0) || !h->c.cur_pic.ptr) {

446 // FIXME write parser so we always have complete frames?

447 if (h->c.cur_pic.ptr) {

448 ff_er_frame_end(&h->c.er, NULL);

449 ff_mpv_frame_end(&h->c);

450 h->c.mb_x = h->c.mb_y = h->c.resync_mb_x = h->c.resync_mb_y = 0;

451 }

452 if ((ret = ff_mpv_frame_start(&h->c, avctx)) < 0)

453 return ret;

454 ff_mpv_er_frame_start_ext(&h->c, 0, h->c.pp_time, h->c.pb_time);

455 } else {

456 if (h->c.cur_pic.ptr->f->pict_type != h->c.pict_type) {

457 av_log(h->c.avctx, AV_LOG_ERROR, "Slice type mismatch\n");

458 return AVERROR_INVALIDDATA;

459 }

460 }

461

462

463 ff_dlog(avctx, "qscale=%d\n", h->c.qscale);

464

465 /* default quantization values */

466 if (h->c.codec_id == AV_CODEC_ID_RV10) {

467 if (h->c.mb_y == 0)

468 h->c.first_slice_line = 1;

469 } else {

470 h->c.first_slice_line = 1;

471 h->c.resync_mb_x = h->c.mb_x;

472 }

473 start_mb_x = h->c.mb_x;

474 h->c.resync_mb_y = h->c.mb_y;

475

476 ff_set_qscale(&h->c, h->c.qscale);

477

478 h->rv10_first_dc_coded[0] = 0;

479 h->rv10_first_dc_coded[1] = 0;

480 h->rv10_first_dc_coded[2] = 0;

481 ff_init_block_index(&h->c);

482

483 /* decode each macroblock */

484 for (h->mb_num_left = mb_count; h->mb_num_left > 0; h->mb_num_left--) {

485 int ret;

486 ff_update_block_index(&h->c, 8, h->c.avctx->lowres, 1);

487 ff_tlog(avctx, "**mb x=%d y=%d\n", h->c.mb_x, h->c.mb_y);

488

489 h->c.mv_dir = MV_DIR_FORWARD;

490 h->c.mv_type = MV_TYPE_16X16;

491 ret = ff_h263_decode_mb(h);

492

493 // Repeat the slice end check from ff_h263_decode_mb with our active

494 // bitstream size

495 if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&h->gb)) {

496 int v = show_bits(&h->gb, 16);

497

498 if (get_bits_count(&h->gb) + 16 > active_bits_size)

499 v >>= get_bits_count(&h->gb) + 16 - active_bits_size;

500

501 if (!v)

502 ret = SLICE_END;

503 }

504 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&h->gb) &&

505 8 * buf_size2 >= get_bits_count(&h->gb)) {

506 active_bits_size = buf_size2 * 8;

507 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",

508 8 * buf_size, active_bits_size);

509 ret = SLICE_OK;

510 }

511

512 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&h->gb)) {

513 av_log(h->c.avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", h->c.mb_x,

514 h->c.mb_y);

515 return AVERROR_INVALIDDATA;

516 }

517 if (h->c.pict_type != AV_PICTURE_TYPE_B)

518 ff_h263_update_motion_val(&h->c);

519 ff_mpv_reconstruct_mb(&h->c, h->block);

520 if (h->loop_filter)

521 ff_h263_loop_filter(&h->c);

522

523 if (++h->c.mb_x == h->c.mb_width) {

524 h->c.mb_x = 0;

525 h->c.mb_y++;

526 ff_init_block_index(&h->c);

527 }

528 if (h->c.mb_x == h->c.resync_mb_x)

529 h->c.first_slice_line = 0;

530 if (ret == SLICE_END)

531 break;

532 }

533

534 ff_er_add_slice(&h->c.er, start_mb_x, h->c.resync_mb_y, h->c.mb_x - 1, h->c.mb_y,

535 ER_MB_END);

536

537 return active_bits_size;

538 }

539

540 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)

541 {

542 return AV_RL32(buf + n * 8);

543 }

544

545 static int rv10_decode_frame(AVCodecContext *avctx, AVFrame *pict,

546 int *got_frame, AVPacket *avpkt)

547 {

548 const uint8_t *buf = avpkt->data;

549 int buf_size = avpkt->size;

550 MpegEncContext *s = avctx->priv_data;

551 int i, ret;

552 int slice_count;

553 const uint8_t *slices_hdr = NULL;

554

555 ff_dlog(avctx, "*****frame %"PRId64" size=%d\n", avctx->frame_num, buf_size);

556

557 /* no supplementary picture */

558 if (buf_size == 0) {

559 return 0;

560 }

561

562 slice_count = (*buf++) + 1;

563 buf_size--;

564

565 if (!slice_count || buf_size <= 8 * slice_count) {

566 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",

567 slice_count);

568 return AVERROR_INVALIDDATA;

569 }

570

571 slices_hdr = buf + 4;

572 buf += 8 * slice_count;

573 buf_size -= 8 * slice_count;

574

575 for (i = 0; i < slice_count; i++) {

576 unsigned offset = get_slice_offset(avctx, slices_hdr, i);

577 int size, size2;

578

579 if (offset >= buf_size)

580 return AVERROR_INVALIDDATA;

581

582 if (i + 1 == slice_count)

583 size = buf_size - offset;

584 else

585 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;

586

587 if (i + 2 >= slice_count)

588 size2 = buf_size - offset;

589 else

590 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;

591

592 if (size <= 0 || size2 <= 0 ||

593 offset + FFMAX(size, size2) > buf_size)

594 return AVERROR_INVALIDDATA;

595

596 if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2, buf_size)) < 0)

597 return ret;

598

599 if (ret > 8 * size)

600 i++;

601 }

602

603 if (s->cur_pic.ptr && s->mb_y >= s->mb_height) {

604 ff_er_frame_end(&s->er, NULL);

605 ff_mpv_frame_end(s);

606

607 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

608 if ((ret = av_frame_ref(pict, s->cur_pic.ptr->f)) < 0)

609 return ret;

610 ff_print_debug_info(s, s->cur_pic.ptr, pict);

611 ff_mpv_export_qp_table(s, pict, s->cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1);

612 } else if (s->last_pic.ptr) {

613 if ((ret = av_frame_ref(pict, s->last_pic.ptr->f)) < 0)

614 return ret;

615 ff_print_debug_info(s, s->last_pic.ptr, pict);

616 ff_mpv_export_qp_table(s, pict,s->last_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1);

617 }

618

619 if (s->last_pic.ptr || s->low_delay) {

620 *got_frame = 1;

621 }

622

623 // so we can detect if frame_end was not called (find some nicer solution...)

624 ff_mpv_unref_picture(&s->cur_pic);

625 }

626

627 return avpkt->size;

628 }

629

630 const FFCodec ff_rv10_decoder = {

631 .p.name = "rv10",

632 CODEC_LONG_NAME("RealVideo 1.0"),

633 .p.type = AVMEDIA_TYPE_VIDEO,

634 .p.id = AV_CODEC_ID_RV10,

635 .priv_data_size = sizeof(RVDecContext),

636 .init = rv10_decode_init,

637 FF_CODEC_DECODE_CB(rv10_decode_frame),

638 .close = ff_mpv_decode_close,

639 .p.capabilities = AV_CODEC_CAP_DR1,

640 .p.max_lowres = 3,

641 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

642 };

643

644 const FFCodec ff_rv20_decoder = {

645 .p.name = "rv20",

646 CODEC_LONG_NAME("RealVideo 2.0"),

647 .p.type = AVMEDIA_TYPE_VIDEO,

648 .p.id = AV_CODEC_ID_RV20,

649 .priv_data_size = sizeof(RVDecContext),

650 .init = rv10_decode_init,

651 FF_CODEC_DECODE_CB(rv10_decode_frame),

652 .close = ff_mpv_decode_close,

653 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,

654 .flush = ff_mpeg_flush,

655 .p.max_lowres = 3,

656 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

657 };

ff_mpv_common_init

av_cold int ff_mpv_common_init(MpegEncContext *s)

init common structure for both encoder and decoder.

Definition: mpegvideo.c:378

MV_TYPE_16X16

#define MV_TYPE_16X16

1 vector for the whole mb

Definition: mpegvideo.h:175

h263data.h

rv_dc_lum

static VLCElem rv_dc_lum[1472]

Definition: rv10.c:81

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:42

RV_GET_MINOR_VER

#define RV_GET_MINOR_VER(x)

Definition: rv10.c:48

thread.h

AVPictureType

Definition: avutil.h:276

int64_t

long long int64_t

Definition: coverity.c:34

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:254

AV_RB32A

#define AV_RB32A(p)

Definition: intreadwrite.h:575

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

AVPacket::data

uint8_t * data

Definition: packet.h:588

rv10_decode_picture_header

static int rv10_decode_picture_header(H263DecContext *const h)

Definition: rv10.c:100

FFCodec

Definition: codec_internal.h:127

VLCElem::len

VLCBaseType len

Definition: vlc.h:37

ff_er_add_slice

void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)

Add a slice.

Definition: error_resilience.c:828

ff_init_block_index

void ff_init_block_index(MpegEncContext *s)

Definition: mpegvideo.c:491

mpegvideo.h

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:91

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:517

RVDecContext

Definition: rv10.c:54

FF_DEBUG_PICT_INFO

#define FF_DEBUG_PICT_INFO

Definition: avcodec.h:1375

MAX_VLC_ENTRIES

#define MAX_VLC_ENTRIES

Definition: rv10.c:51

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:383

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:337

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

SLICE_OK

#define SLICE_OK

Definition: h261dec.c:40

VLCElem::sym

VLCBaseType sym

Definition: vlc.h:36

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:607

ff_h263_update_motion_val

void ff_h263_update_motion_val(MpegEncContext *s)

Definition: h263.c:56

AVRational::num

int num

Numerator.

Definition: rational.h:59

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

mpegvideodec.h

rv10_build_vlc

static av_cold void rv10_build_vlc(VLCElem vlc[], int table_size, const uint16_t len_count[15], const uint8_t sym_rl[][2], int sym_rl_elems)

Definition: rv10.c:309

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

h263dec.h

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:106

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:515

AVCodecContext::has_b_frames

int has_b_frames

Size of the frame reordering buffer in the decoder.

Definition: avcodec.h:697

ff_er_frame_end

void ff_er_frame_end(ERContext *s, int *decode_error_flags)

Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...

Definition: error_resilience.c:898

ff_mpeg_flush

av_cold void ff_mpeg_flush(AVCodecContext *avctx)

Definition: mpegvideo_dec.c:452

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:347

RVDecContext::h

H263DecContext h

Definition: rv10.c:55

ff_h263_chroma_qscale_table

const uint8_t ff_h263_chroma_qscale_table[32]

Definition: h263data.c:260

#define s(width, name)

Definition: cbs_vp9.c:198

RV_GET_MAJOR_VER

#define RV_GET_MAJOR_VER(x)

Definition: rv10.c:47

ff_mpeg1_dc_scale_table

static const uint8_t *const ff_mpeg1_dc_scale_table

Definition: mpegvideodata.h:32

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

decode.h

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:332

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:441

ff_mpv_common_end

av_cold void ff_mpv_common_end(MpegEncContext *s)

Definition: mpegvideo.c:447

ff_mpv_unref_picture

void ff_mpv_unref_picture(MPVWorkPicture *pic)

Definition: mpegpicture.c:98

RVDecContext::orig_height

int orig_height

Definition: rv10.c:57

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

ff_h263_decode_mb

int ff_h263_decode_mb(H263DecContext *const h)

Definition: ituh263dec.c:784

ff_mpv_export_qp_table

int ff_mpv_export_qp_table(const MpegEncContext *s, AVFrame *f, const MPVPicture *p, int qp_type)

Definition: mpegvideo_dec.c:413

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

RVDecContext::orig_width

int orig_width

Definition: rv10.c:57

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

ERROR_SKIP_FRAME

#define ERROR_SKIP_FRAME

ff_mpv_decode_close

av_cold int ff_mpv_decode_close(AVCodecContext *avctx)

Definition: mpegvideo_dec.c:166

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:278

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:391

ff_set_qscale

void ff_set_qscale(MpegEncContext *s, int qscale)

set qscale and update qscale dependent variables.

Definition: mpegvideo.c:524

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:651

FF_MPV_QSCALE_TYPE_MPEG1

#define FF_MPV_QSCALE_TYPE_MPEG1

Definition: mpegvideodec.h:40

AVOnce

#define AVOnce

Definition: thread.h:202

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

rv10_decode_frame

static int rv10_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)

Definition: rv10.c:545

rv_chrom_len_count

static const uint16_t rv_chrom_len_count[15]

Definition: rv10.c:77

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

ff_rv20_decoder

const FFCodec ff_rv20_decoder

Definition: rv10.c:644

Definition: af_crystalizer.c:122

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:550

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:589

RV_GET_MICRO_VER

#define RV_GET_MICRO_VER(x)

Definition: rv10.c:49

av_frame_ref

int av_frame_ref(AVFrame *dst, const AVFrame *src)

Set up a new reference to the data described by the source frame.

Definition: frame.c:278

codec_internal.h

ff_update_block_index

static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)

Definition: mpegvideo.h:337

size

int size

Definition: twinvq_data.h:10344

VLCElem

Definition: vlc.h:32

ff_mpv_frame_start

int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)

generic function called after decoding the header and before a frame is decoded.

Definition: mpegvideo_dec.c:347

ff_h263_decode_mba

int ff_h263_decode_mba(H263DecContext *const h)

Definition: ituh263dec.c:142

ff_vlc_init_table_from_lengths

av_cold void ff_vlc_init_table_from_lengths(VLCElem table[], int table_size, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)

Definition: vlc.c:353

mpegvideodata.h

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

rv10_decode_packet

static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int buf_size2, int whole_size)

Definition: rv10.c:411

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:221

rv_sym_run_len

static const uint8_t rv_sym_run_len[][2]

Definition: rv10.c:64

rv10_init_static

static av_cold void rv10_init_static(void)

Definition: rv10.c:331

ff_print_debug_info

void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)

Definition: mpegvideo_dec.c:406

AV_CODEC_ID_RV10

@ AV_CODEC_ID_RV10

Definition: codec_id.h:57

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

AVCodecContext::extradata

uint8_t * extradata

Out-of-band global headers that may be used by some codecs.

Definition: avcodec.h:514

show_bits

static unsigned int show_bits(GetBitContext *s, int n)

Show 1-25 bits.

Definition: get_bits.h:373

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:57

AV_CODEC_ID_RV20

@ AV_CODEC_ID_RV20

Definition: codec_id.h:58

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

ff_h263_decode_init

av_cold int ff_h263_decode_init(AVCodecContext *avctx)

Definition: h263dec.c:91

ff_rv10_decoder

const FFCodec ff_rv10_decoder

Definition: rv10.c:630

avcodec.h

AVCodecContext::frame_num

int64_t frame_num

Frame counter, set by libavcodec.

Definition: avcodec.h:1878

get_slice_offset

static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)

Definition: rv10.c:540

ret

Definition: filter_design.txt:187

ff_aic_dc_scale_table

const uint8_t ff_aic_dc_scale_table[32]

Definition: h263data.c:245

rv20_decode_picture_header

static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)

Definition: rv10.c:157

ff_mpv_er_frame_start_ext

static void ff_mpv_er_frame_start_ext(MPVContext *const s, int partitioned_frame, uint16_t pp_time, uint16_t pb_time)

Definition: mpeg_er.h:27

ff_rv_decode_dc

int ff_rv_decode_dc(H263DecContext *const h, int n)

Definition: rv10.c:83

ff_h263_loop_filter

void ff_h263_loop_filter(MpegEncContext *s)

Definition: h263.c:97

ff_mpeg4_init_direct_mv

void ff_mpeg4_init_direct_mv(MpegEncContext *s)

Definition: mpeg4video.c:73

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

H263DecContext

Definition: h263dec.h:43

rv_lum_len_count

static const uint16_t rv_lum_len_count[15]

Definition: rv10.c:73

AVCodecContext

main external API structure.

Definition: avcodec.h:431