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 "error_resilience.h"

35 #include "h263.h"

36 #include "h263data.h"

37 #include "internal.h"

38 #include "mpeg_er.h"

39 #include "mpegutils.h"

40 #include "mpegvideo.h"

41 #include "mpeg4video.h"

42 #include "mpegvideodata.h"

43 #include "rv10.h"

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

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

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

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

50 #define DC_VLC_BITS 9

52 typedef struct RVDecContext {

53 MpegEncContext m;

54 int sub_id;

55 int orig_width, orig_height;

56 } RVDecContext;

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

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

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

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

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

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

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

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

66 { 255, 127 }, { 128, 127 }, { 127, 255 }, { 128, 255 },

67 };

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

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

71 static const uint16_t rv_lum_len_count[15] = {

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

73 };

75 static const uint16_t rv_chrom_len_count[15] = {

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

77 };

79 static VLC rv_dc_lum, rv_dc_chrom;

81 int ff_rv_decode_dc(MpegEncContext *s, int n)

82 {

83 int code;

85 if (n < 4) {

86 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);

87 } else {

88 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);

89 if (code < 0) {

90 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");

91 return -1;

92 }

93 }

94 return code;

95 }

97 /* read RV 1.0 compatible frame header */

98 static int rv10_decode_picture_header(MpegEncContext *s)

99 {

100 int mb_count, pb_frame, marker, mb_xy;

101

102 marker = get_bits1(&s->gb);

103

104 if (get_bits1(&s->gb))

105 s->pict_type = AV_PICTURE_TYPE_P;

106 else

107 s->pict_type = AV_PICTURE_TYPE_I;

108

109 if (!marker)

110 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");

111

112 pb_frame = get_bits1(&s->gb);

113

114 ff_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);

115

116 if (pb_frame) {

117 avpriv_request_sample(s->avctx, "PB-frame");

118 return AVERROR_PATCHWELCOME;

119 }

120

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

122 if (s->qscale == 0) {

123 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");

124 return AVERROR_INVALIDDATA;

125 }

126

127 if (s->pict_type == AV_PICTURE_TYPE_I) {

128 if (s->rv10_version == 3) {

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

130 s->last_dc[0] = get_bits(&s->gb, 8);

131 s->last_dc[1] = get_bits(&s->gb, 8);

132 s->last_dc[2] = get_bits(&s->gb, 8);

133 ff_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],

134 s->last_dc[1], s->last_dc[2]);

135 }

136 }

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

138 * to display the macroblocks is coded here */

139

140 mb_xy = s->mb_x + s->mb_y * s->mb_width;

141 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {

142 s->mb_x = get_bits(&s->gb, 6); /* mb_x */

143 s->mb_y = get_bits(&s->gb, 6); /* mb_y */

144 mb_count = get_bits(&s->gb, 12);

145 } else {

146 s->mb_x = 0;

147 s->mb_y = 0;

148 mb_count = s->mb_width * s->mb_height;

149 }

150 skip_bits(&s->gb, 3); /* ignored */

151 s->f_code = 1;

152 s->unrestricted_mv = 1;

153

154 return mb_count;

155 }

156

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

158 {

159 MpegEncContext *s = &rv->m;

160 int seq, mb_pos, i, ret;

161 int rpr_max;

162

163 i = get_bits(&s->gb, 2);

164 switch (i) {

165 case 0:

166 s->pict_type = AV_PICTURE_TYPE_I;

167 break;

168 case 1:

169 s->pict_type = AV_PICTURE_TYPE_I;

170 break; // hmm ...

171 case 2:

172 s->pict_type = AV_PICTURE_TYPE_P;

173 break;

174 case 3:

175 s->pict_type = AV_PICTURE_TYPE_B;

176 break;

177 default:

178 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");

179 return AVERROR_INVALIDDATA;

180 }

181

182 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {

183 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");

184 return -1;

185 }

186 if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {

187 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");

188 return AVERROR_INVALIDDATA;

189 }

190

191 if (get_bits1(&s->gb)) {

192 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");

193 return AVERROR_INVALIDDATA;

194 }

195

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

197 if (s->qscale == 0) {

198 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");

199 return AVERROR_INVALIDDATA;

200 }

201

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

203 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;

204

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

206 seq = get_bits(&s->gb, 8) << 7;

207 else

208 seq = get_bits(&s->gb, 13) << 2;

209

210 rpr_max = s->avctx->extradata[1] & 7;

211 if (rpr_max) {

212 int f, new_w, new_h;

213 int rpr_bits = av_log2(rpr_max) + 1;

214

215 f = get_bits(&s->gb, rpr_bits);

216

217 if (f) {

218 if (s->avctx->extradata_size < 8 + 2 * f) {

219 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");

220 return AVERROR_INVALIDDATA;

221 }

222

223 new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];

224 new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];

225 } else {

226 new_w = rv->orig_width;

227 new_h = rv->orig_height;

228 }

229 if (new_w != s->width || new_h != s->height || !s->context_initialized) {

230 AVRational old_aspect = s->avctx->sample_aspect_ratio;

231 av_log(s->avctx, AV_LOG_DEBUG,

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

233 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)

234 return AVERROR_INVALIDDATA;

235

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

237 return AVERROR_INVALIDDATA;

238

239 ff_mpv_common_end(s);

240

241 // attempt to keep aspect during typical resolution switches

242 if (!old_aspect.num)

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

244 if (2 * (int64_t)new_w * s->height == (int64_t)new_h * s->width)

245 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});

246 if ((int64_t)new_w * s->height == 2 * (int64_t)new_h * s->width)

247 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});

248

249 ret = ff_set_dimensions(s->avctx, new_w, new_h);

250 if (ret < 0)

251 return ret;

252

253 s->width = new_w;

254 s->height = new_h;

255 if ((ret = ff_mpv_common_init(s)) < 0)

256 return ret;

257 }

258

259 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {

260 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);

261 }

262 }

263 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)

264 return AVERROR_INVALIDDATA;

265

266 mb_pos = ff_h263_decode_mba(s);

267

268 seq |= s->time & ~0x7FFF;

269 if (seq - s->time > 0x4000)

270 seq -= 0x8000;

271 if (seq - s->time < -0x4000)

272 seq += 0x8000;

273

274 if (seq != s->time) {

275 if (s->pict_type != AV_PICTURE_TYPE_B) {

276 s->time = seq;

277 s->pp_time = s->time - s->last_non_b_time;

278 s->last_non_b_time = s->time;

279 } else {

280 s->time = seq;

281 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);

282 }

283 }

284 if (s->pict_type == AV_PICTURE_TYPE_B) {

285 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {

286 av_log(s->avctx, AV_LOG_DEBUG,

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

288 #define ERROR_SKIP_FRAME -123

289 return ERROR_SKIP_FRAME;

290 }

291 ff_mpeg4_init_direct_mv(s);

292 }

293

294 s->no_rounding = get_bits1(&s->gb);

295

296 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)

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

298 skip_bits(&s->gb, 5);

299

300 s->f_code = 1;

301 s->unrestricted_mv = 1;

302 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;

303 s->modified_quant = 1;

304 if (!s->avctx->lowres)

305 s->loop_filter = 1;

306

307 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {

308 av_log(s->avctx, AV_LOG_INFO,

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

310 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,

311 s->no_rounding);

312 }

313

314 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);

315

316 return s->mb_width * s->mb_height - mb_pos;

317 }

318

319 static av_cold void rv10_build_vlc(VLC *vlc, const uint16_t len_count[15],

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

321 {

322 uint16_t syms[MAX_VLC_ENTRIES];

323 uint8_t lens[MAX_VLC_ENTRIES];

324 unsigned nb_syms = 0, nb_lens = 0;

325

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

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

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

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

330 }

331

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

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

334 lens[nb_lens] = i + 2;

335 av_assert1(nb_lens == nb_syms);

336 ff_init_vlc_from_lengths(vlc, DC_VLC_BITS, nb_lens, lens, 1,

337 syms, 2, 2, 0, INIT_VLC_STATIC_OVERLONG, NULL);

338 }

339

340 static av_cold void rv10_init_static(void)

341 {

342 static VLC_TYPE table[1472 + 992][2];

343

344 rv_dc_lum.table = table;

345 rv_dc_lum.table_allocated = 1472;

346 rv10_build_vlc(&rv_dc_lum, rv_lum_len_count,

347 rv_sym_run_len, FF_ARRAY_ELEMS(rv_sym_run_len));

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

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

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

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

352 rv_dc_lum.table[(0x7F << (DC_VLC_BITS - 7)) + i][1] = 18;

353 }

354 rv_dc_chrom.table = &table[1472];

355 rv_dc_chrom.table_allocated = 992;

356 rv10_build_vlc(&rv_dc_chrom, rv_chrom_len_count,

357 rv_sym_run_len, FF_ARRAY_ELEMS(rv_sym_run_len) - 2);

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

359 /* Same as above. */

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

361 rv_dc_chrom.table[(0x1FE << (DC_VLC_BITS - 9)) + i][1] = 18;

362 }

363 ff_h263_decode_init_vlc();

364 }

365

366 static av_cold int rv10_decode_init(AVCodecContext *avctx)

367 {

368 static AVOnce init_static_once = AV_ONCE_INIT;

369 RVDecContext *rv = avctx->priv_data;

370 MpegEncContext *s = &rv->m;

371 int major_ver, minor_ver, micro_ver, ret;

372

373 if (avctx->extradata_size < 8) {

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

375 return AVERROR_INVALIDDATA;

376 }

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

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

379 return ret;

380

381 ff_mpv_decode_init(s, avctx);

382

383 s->out_format = FMT_H263;

384

385 rv->orig_width =

386 s->width = avctx->coded_width;

387 rv->orig_height =

388 s->height = avctx->coded_height;

389

390 s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;

391 rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);

392

393 major_ver = RV_GET_MAJOR_VER(rv->sub_id);

394 minor_ver = RV_GET_MINOR_VER(rv->sub_id);

395 micro_ver = RV_GET_MICRO_VER(rv->sub_id);

396

397 s->low_delay = 1;

398 switch (major_ver) {

399 case 1:

400 s->rv10_version = micro_ver ? 3 : 1;

401 s->obmc = micro_ver == 2;

402 break;

403 case 2:

404 if (minor_ver >= 2) {

405 s->low_delay = 0;

406 s->avctx->has_b_frames = 1;

407 }

408 break;

409 default:

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

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

412 return AVERROR_PATCHWELCOME;

413 }

414

415 if (avctx->debug & FF_DEBUG_PICT_INFO) {

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

417 ((uint32_t *) avctx->extradata)[0]);

418 }

419

420 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

421

422 ff_mpv_idct_init(s);

423 if ((ret = ff_mpv_common_init(s)) < 0)

424 return ret;

425

426 ff_h263dsp_init(&s->h263dsp);

427

428 /* init static VLCs */

429 ff_thread_once(&init_static_once, rv10_init_static);

430

431 return 0;

432 }

433

434 static av_cold int rv10_decode_end(AVCodecContext *avctx)

435 {

436 MpegEncContext *s = avctx->priv_data;

437

438 ff_mpv_common_end(s);

439 return 0;

440 }

441

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

443 int buf_size, int buf_size2, int whole_size)

444 {

445 RVDecContext *rv = avctx->priv_data;

446 MpegEncContext *s = &rv->m;

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

448

449 active_bits_size = buf_size * 8;

450 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);

451 if (s->codec_id == AV_CODEC_ID_RV10)

452 mb_count = rv10_decode_picture_header(s);

453 else

454 mb_count = rv20_decode_picture_header(rv, whole_size);

455 if (mb_count < 0) {

456 if (mb_count != ERROR_SKIP_FRAME)

457 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");

458 return AVERROR_INVALIDDATA;

459 }

460

461 if (s->mb_x >= s->mb_width ||

462 s->mb_y >= s->mb_height) {

463 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);

464 return AVERROR_INVALIDDATA;

465 }

466 mb_pos = s->mb_y * s->mb_width + s->mb_x;

467 left = s->mb_width * s->mb_height - mb_pos;

468 if (mb_count > left) {

469 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");

470 return AVERROR_INVALIDDATA;

471 }

472

473 if (whole_size < s->mb_width * s->mb_height / 8)

474 return AVERROR_INVALIDDATA;

475

476 if ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {

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

478 if (s->current_picture_ptr) {

479 ff_er_frame_end(&s->er);

480 ff_mpv_frame_end(s);

481 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;

482 }

483 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)

484 return ret;

485 ff_mpeg_er_frame_start(s);

486 } else {

487 if (s->current_picture_ptr->f->pict_type != s->pict_type) {

488 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");

489 return AVERROR_INVALIDDATA;

490 }

491 }

492

493

494 ff_dlog(avctx, "qscale=%d\n", s->qscale);

495

496 /* default quantization values */

497 if (s->codec_id == AV_CODEC_ID_RV10) {

498 if (s->mb_y == 0)

499 s->first_slice_line = 1;

500 } else {

501 s->first_slice_line = 1;

502 s->resync_mb_x = s->mb_x;

503 }

504 start_mb_x = s->mb_x;

505 s->resync_mb_y = s->mb_y;

506 if (s->h263_aic) {

507 s->y_dc_scale_table =

508 s->c_dc_scale_table = ff_aic_dc_scale_table;

509 } else {

510 s->y_dc_scale_table =

511 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;

512 }

513

514 if (s->modified_quant)

515 s->chroma_qscale_table = ff_h263_chroma_qscale_table;

516

517 ff_set_qscale(s, s->qscale);

518

519 s->rv10_first_dc_coded[0] = 0;

520 s->rv10_first_dc_coded[1] = 0;

521 s->rv10_first_dc_coded[2] = 0;

522 s->block_wrap[0] =

523 s->block_wrap[1] =

524 s->block_wrap[2] =

525 s->block_wrap[3] = s->b8_stride;

526 s->block_wrap[4] =

527 s->block_wrap[5] = s->mb_stride;

528 ff_init_block_index(s);

529

530 /* decode each macroblock */

531 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {

532 int ret;

533 ff_update_block_index(s);

534 ff_tlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);

535

536 s->mv_dir = MV_DIR_FORWARD;

537 s->mv_type = MV_TYPE_16X16;

538 ret = ff_h263_decode_mb(s, s->block);

539

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

541 // bitstream size

542 if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&s->gb)) {

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

544

545 if (get_bits_count(&s->gb) + 16 > active_bits_size)

546 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;

547

548 if (!v)

549 ret = SLICE_END;

550 }

551 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&

552 8 * buf_size2 >= get_bits_count(&s->gb)) {

553 active_bits_size = buf_size2 * 8;

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

555 8 * buf_size, active_bits_size);

556 ret = SLICE_OK;

557 }

558

559 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {

560 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,

561 s->mb_y);

562 return AVERROR_INVALIDDATA;

563 }

564 if (s->pict_type != AV_PICTURE_TYPE_B)

565 ff_h263_update_motion_val(s);

566 ff_mpv_reconstruct_mb(s, s->block);

567 if (s->loop_filter)

568 ff_h263_loop_filter(s);

569

570 if (++s->mb_x == s->mb_width) {

571 s->mb_x = 0;

572 s->mb_y++;

573 ff_init_block_index(s);

574 }

575 if (s->mb_x == s->resync_mb_x)

576 s->first_slice_line = 0;

577 if (ret == SLICE_END)

578 break;

579 }

580

581 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,

582 ER_MB_END);

583

584 return active_bits_size;

585 }

586

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

588 {

589 if (avctx->slice_count)

590 return avctx->slice_offset[n];

591 else

592 return AV_RL32(buf + n * 8);

593 }

594

595 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

596 AVPacket *avpkt)

597 {

598 const uint8_t *buf = avpkt->data;

599 int buf_size = avpkt->size;

600 MpegEncContext *s = avctx->priv_data;

601 AVFrame *pict = data;

602 int i, ret;

603 int slice_count;

604 const uint8_t *slices_hdr = NULL;

605

606 ff_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);

607

608 /* no supplementary picture */

609 if (buf_size == 0) {

610 return 0;

611 }

612

613 if (!avctx->slice_count) {

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

615 buf_size--;

616

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

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

619 slice_count);

620 return AVERROR_INVALIDDATA;

621 }

622

623 slices_hdr = buf + 4;

624 buf += 8 * slice_count;

625 buf_size -= 8 * slice_count;

626 } else

627 slice_count = avctx->slice_count;

628

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

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

631 int size, size2;

632

633 if (offset >= buf_size)

634 return AVERROR_INVALIDDATA;

635

636 if (i + 1 == slice_count)

637 size = buf_size - offset;

638 else

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

640

641 if (i + 2 >= slice_count)

642 size2 = buf_size - offset;

643 else

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

645

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

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

648 return AVERROR_INVALIDDATA;

649

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

651 return ret;

652

653 if (ret > 8 * size)

654 i++;

655 }

656

657 if (s->current_picture_ptr && s->mb_y >= s->mb_height) {

658 ff_er_frame_end(&s->er);

659 ff_mpv_frame_end(s);

660

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

662 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)

663 return ret;

664 ff_print_debug_info(s, s->current_picture_ptr, pict);

665 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);

666 } else if (s->last_picture_ptr) {

667 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)

668 return ret;

669 ff_print_debug_info(s, s->last_picture_ptr, pict);

670 ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);

671 }

672

673 if (s->last_picture_ptr || s->low_delay) {

674 *got_frame = 1;

675 }

676

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

678 s->current_picture_ptr = NULL;

679 }

680

681 return avpkt->size;

682 }

683

684 const AVCodec ff_rv10_decoder = {

685 .name = "rv10",

686 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),

687 .type = AVMEDIA_TYPE_VIDEO,

688 .id = AV_CODEC_ID_RV10,

689 .priv_data_size = sizeof(RVDecContext),

690 .init = rv10_decode_init,

691 .close = rv10_decode_end,

692 .decode = rv10_decode_frame,

693 .capabilities = AV_CODEC_CAP_DR1,

694 .max_lowres = 3,

695 .pix_fmts = (const enum AVPixelFormat[]) {

696 AV_PIX_FMT_YUV420P,

697 AV_PIX_FMT_NONE

698 },

699 };

700

701 const AVCodec ff_rv20_decoder = {

702 .name = "rv20",

703 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),

704 .type = AVMEDIA_TYPE_VIDEO,

705 .id = AV_CODEC_ID_RV20,

706 .priv_data_size = sizeof(RVDecContext),

707 .init = rv10_decode_init,

708 .close = rv10_decode_end,

709 .decode = rv10_decode_frame,

710 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,

711 .flush = ff_mpeg_flush,

712 .max_lowres = 3,

713 .pix_fmts = (const enum AVPixelFormat[]) {

714 AV_PIX_FMT_YUV420P,

715 AV_PIX_FMT_NONE

716 },

717 };

ff_mpv_common_init

av_cold int ff_mpv_common_init(MpegEncContext *s)

init common structure for both encoder and decoder.

Definition: mpegvideo.c:926

AVCodec

AVCodec.

Definition: codec.h:202

MV_TYPE_16X16

#define MV_TYPE_16X16

1 vector for the whole mb

Definition: mpegvideo.h:255

h263data.h

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

RV_GET_MINOR_VER

#define RV_GET_MINOR_VER(x)

Definition: rv10.c:46

thread.h

ff_mpeg1_dc_scale_table

const uint8_t ff_mpeg1_dc_scale_table[128]

Definition: mpegvideodata.c:33

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:220

AVFrame

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

Definition: frame.h:317

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

AVCodecContext::slice_offset

int * slice_offset

slice offsets in the frame in bytes

Definition: avcodec.h:744

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

table

static const uint16_t table[]

Definition: prosumer.c:206

data

const char data[16]

Definition: mxf.c:143

ff_h263_decode_mba

int ff_h263_decode_mba(MpegEncContext *s)

Definition: ituh263dec.c:138

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:798

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:826

ff_init_block_index

void ff_init_block_index(MpegEncContext *s)

Definition: mpegvideo.c:2286

mpegvideo.h

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

mpegutils.h

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:660

RVDecContext

Definition: rv10.c:52

FF_DEBUG_PICT_INFO

#define FF_DEBUG_PICT_INFO

Definition: avcodec.h:1303

AVCodecContext::slice_count

int slice_count

slice count

Definition: avcodec.h:737

MAX_VLC_ENTRIES

#define MAX_VLC_ENTRIES

Definition: rv10.c:49

init

static int init

Definition: av_tx.c:47

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:468

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:380

VLC_TYPE

#define VLC_TYPE

Definition: vlc.h:24

ff_h263dsp_init

av_cold void ff_h263dsp_init(H263DSPContext *ctx)

Definition: h263dsp.c:117

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:571

SLICE_END

#define SLICE_END

end marker found

Definition: mpegvideo.h:511

ff_h263_update_motion_val

void ff_h263_update_motion_val(MpegEncContext *s)

Definition: h263.c:53

AVRational::num

int num

Numerator.

Definition: rational.h:59

rv10_decode_end

static av_cold int rv10_decode_end(AVCodecContext *avctx)

Definition: rv10.c:434

ff_h263_decode_init_vlc

void ff_h263_decode_init_vlc(void)

Definition: ituh263dec.c:108

ff_init_vlc_from_lengths

int ff_init_vlc_from_lengths(VLC *vlc_arg, 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, void *logctx)

Build VLC decoding tables suitable for use with get_vlc2()

Definition: bitstream.c:381

ff_mpv_common_end

void ff_mpv_common_end(MpegEncContext *s)

Definition: mpegvideo.c:1128

ff_thread_once

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

Definition: thread.h:175

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

rv10_decode_picture_header

static int rv10_decode_picture_header(MpegEncContext *s)

Definition: rv10.c:98

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:71

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:485

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:257

RV_GET_MAJOR_VER

#define RV_GET_MAJOR_VER(x)

Definition: rv10.c:45

ff_mpeg_er_frame_start

void ff_mpeg_er_frame_start(MpegEncContext *s)

Definition: mpeg_er.c:46

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:296

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

rv_dc_chrom

static VLC rv_dc_chrom

Definition: rv10.c:79

rv10_build_vlc

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

Definition: rv10.c:319

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:66

#define f(width, name)

Definition: cbs_vp9.c:255

RVDecContext::orig_height

int orig_height

Definition: rv10.c:55

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:173

flush

static void flush(AVCodecContext *avctx)

Definition: aacdec_template.c:593

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:55

ff_mpv_idct_init

av_cold void ff_mpv_idct_init(MpegEncContext *s)

Definition: mpegvideo.c:331

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

ERROR_SKIP_FRAME

#define ERROR_SKIP_FRAME

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:499

ff_set_qscale

void ff_set_qscale(MpegEncContext *s, int qscale)

set qscale and update qscale dependent variables.

Definition: mpegvideo.c:2351

AVOnce

#define AVOnce

Definition: thread.h:172

rv_chrom_len_count

static const uint16_t rv_chrom_len_count[15]

Definition: rv10.c:75

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:29

VLC::table_allocated

int table_allocated

Definition: vlc.h:29

rv_dc_lum

static VLC rv_dc_lum

Definition: rv10.c:79

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:374

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

RV_GET_MICRO_VER

#define RV_GET_MICRO_VER(x)

Definition: rv10.c:47

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:325

FF_QSCALE_TYPE_MPEG1

#define FF_QSCALE_TYPE_MPEG1

Definition: internal.h:96

size

int size

Definition: twinvq_data.h:10344

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:96

ff_mpeg_flush

void ff_mpeg_flush(AVCodecContext *avctx)

Definition: mpegvideo.c:2319

ff_rv20_decoder

const AVCodec ff_rv20_decoder

Definition: rv10.c:701

RVDecContext::m

MpegEncContext m

Definition: rv10.c:53

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

ff_mpv_export_qp_table

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

Definition: mpegvideo.c:1439

ff_print_debug_info

void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)

Definition: mpegvideo.c:1432

rv10.h

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:442

ff_rv10_decoder

const AVCodec ff_rv10_decoder

Definition: rv10.c:684

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

rv_sym_run_len

static const uint8_t rv_sym_run_len[][2]

Definition: rv10.c:62

ff_rv_decode_dc

int ff_rv_decode_dc(MpegEncContext *s, int n)

Definition: rv10.c:81

ff_update_block_index

static void ff_update_block_index(MpegEncContext *s)

Definition: mpegvideo.h:741

rv10_init_static

static av_cold void rv10_init_static(void)

Definition: rv10.c:340

FMT_H263

@ FMT_H263

Definition: mpegutils.h:125

AV_CODEC_ID_RV10

@ AV_CODEC_ID_RV10

Definition: codec_id.h:55

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

Definition: cbs_h2645.c:271

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

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:484

show_bits

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

Show 1-25 bits.

Definition: get_bits.h:447

av_assert1

#define av_assert1(cond)

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

Definition: avassert.h:53

AV_CODEC_ID_RV20

@ AV_CODEC_ID_RV20

Definition: codec_id.h:56

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:593

ff_mpv_frame_end

void ff_mpv_frame_end(MpegEncContext *s)

Definition: mpegvideo.c:1424

avcodec.h

get_slice_offset

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

Definition: rv10.c:587

ret

Definition: filter_design.txt:187

SLICE_OK

#define SLICE_OK

Definition: mpegvideo.h:509

INIT_VLC_STATIC_OVERLONG

#define INIT_VLC_STATIC_OVERLONG

Definition: vlc.h:96

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_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.c:1200

ff_h263_loop_filter

void ff_h263_loop_filter(MpegEncContext *s)

Definition: h263.c:146

ff_mpeg4_init_direct_mv

void ff_mpeg4_init_direct_mv(MpegEncContext *s)

Definition: mpeg4video.c:83

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

rv_lum_len_count

static const uint16_t rv_lum_len_count[15]

Definition: rv10.c:71

AVCodecContext

main external API structure.

Definition: avcodec.h:383

AV_PICTURE_TYPE_B

@ AV_PICTURE_TYPE_B