FFmpeg: libavcodec/svq1enc.c Source File

FFmpeg

[フレーム]

libavcodec

svq1enc.c

Go to the documentation of this file.

1 /*

2 * SVQ1 Encoder

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * Sorenson Vector Quantizer #1 (SVQ1) video codec.

25 * For more information of the SVQ1 algorithm, visit:

26 * http://www.pcisys.net/~melanson/codecs/

27 */

29 #include "libavutil/emms.h"

30 #include "avcodec.h"

31 #include "codec_internal.h"

32 #include "encode.h"

33 #include "hpeldsp.h"

34 #include "me_cmp.h"

35 #include "mpegvideo.h"

36 #include "h263.h"

37 #include "h263enc.h"

38 #include "internal.h"

39 #include "mpegutils.h"

40 #include "packet_internal.h"

41 #include "put_bits.h"

42 #include "svq1.h"

43 #include "svq1encdsp.h"

44 #include "svq1enc_cb.h"

45 #include "version.h"

47 #include "libavutil/avassert.h"

48 #include "libavutil/frame.h"

49 #include "libavutil/mem_internal.h"

51 // Workaround for GCC bug 102513

52 #if AV_GCC_VERSION_AT_LEAST(10, 0) && AV_GCC_VERSION_AT_MOST(12, 0) \

53 && !defined(__clang__) && !defined(__INTEL_COMPILER)

54 #pragma GCC optimize ("no-ipa-cp-clone")

55 #endif

57 typedef struct SVQ1EncContext {

58 /* FIXME: Needed for motion estimation, should not be used for anything

59 * else, the idea is to make the motion estimation eventually independent

60 * of MpegEncContext, so this will be removed then. */

61 MpegEncContext m;

62 AVCodecContext *avctx;

63 MECmpContext mecc;

64 HpelDSPContext hdsp;

65 AVFrame *current_picture;

66 AVFrame *last_picture;

68 /* Some compression statistics */

69 enum AVPictureType pict_type;

70 int quality;

72 /* why ooh why this sick breadth first order,

73 * everything is slower and more complex */

74 PutBitContext reorder_pb[6];

76 int frame_width;

77 int frame_height;

79 /* Y plane block dimensions */

80 int y_block_width;

81 int y_block_height;

83 /* U & V plane (C planes) block dimensions */

84 int c_block_width;

85 int c_block_height;

87 DECLARE_ALIGNED(16, int16_t, encoded_block_levels)[6][7][256];

89 uint16_t *mb_type;

90 uint32_t *dummy;

91 int16_t (*motion_val8[3])[2];

92 int16_t (*motion_val16[3])[2];

94 int64_t rd_total;

96 uint8_t *scratchbuf;

98 int motion_est;

100 SVQ1EncDSPContext svq1encdsp;

101 } SVQ1EncContext;

102

103 static void svq1_write_header(SVQ1EncContext *s, PutBitContext *pb, int frame_type)

104 {

105 int i;

106

107 /* frame code */

108 put_bits(pb, 22, 0x20);

109

110 /* temporal reference (sure hope this is a "don't care") */

111 put_bits(pb, 8, 0x00);

112

113 /* frame type */

114 put_bits(pb, 2, frame_type - 1);

115

116 if (frame_type == AV_PICTURE_TYPE_I) {

117 /* no checksum since frame code is 0x20 */

118 /* no embedded string either */

119 /* output 5 unknown bits (2 + 2 + 1) */

120 put_bits(pb, 5, 2); /* 2 needed by quicktime decoder */

121

122 i = ff_match_2uint16(ff_svq1_frame_size_table,

123 FF_ARRAY_ELEMS(ff_svq1_frame_size_table),

124 s->frame_width, s->frame_height);

125 put_bits(pb, 3, i);

126

127 if (i == 7) {

128 put_bits(pb, 12, s->frame_width);

129 put_bits(pb, 12, s->frame_height);

130 }

131 }

132

133 /* no checksum or extra data (next 2 bits get 0) */

134 put_bits(pb, 2, 0);

135 }

136

137 #define QUALITY_THRESHOLD 100

138 #define THRESHOLD_MULTIPLIER 0.6

139

140 static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref,

141 uint8_t *decoded, int stride, unsigned level,

142 int threshold, int lambda, int intra)

143 {

144 int count, y, x, i, j, split, best_mean, best_score, best_count;

145 int best_vector[6];

146 int block_sum[7] = { 0, 0, 0, 0, 0, 0 };

147 int w = 2 << (level + 2 >> 1);

148 int h = 2 << (level + 1 >> 1);

149 int size = w * h;

150 int16_t (*block)[256] = s->encoded_block_levels[level];

151 const int8_t *codebook_sum, *codebook;

152 const uint16_t(*mean_vlc)[2];

153 const uint8_t(*multistage_vlc)[2];

154

155 best_score = 0;

156 // FIXME: Optimize, this does not need to be done multiple times.

157 if (intra) {

158 // level is 5 when encode_block is called from svq1_encode_plane

159 // and always < 4 when called recursively from this function.

160 codebook_sum = level < 4 ? svq1_intra_codebook_sum[level] : NULL;

161 codebook = ff_svq1_intra_codebooks[level];

162 mean_vlc = ff_svq1_intra_mean_vlc;

163 multistage_vlc = ff_svq1_intra_multistage_vlc[level];

164 for (y = 0; y < h; y++) {

165 for (x = 0; x < w; x++) {

166 int v = src[x + y * stride];

167 block[0][x + w * y] = v;

168 best_score += v * v;

169 block_sum[0] += v;

170 }

171 }

172 } else {

173 // level is 5 or < 4, see above for details.

174 codebook_sum = level < 4 ? svq1_inter_codebook_sum[level] : NULL;

175 codebook = ff_svq1_inter_codebooks[level];

176 mean_vlc = ff_svq1_inter_mean_vlc + 256;

177 multistage_vlc = ff_svq1_inter_multistage_vlc[level];

178 for (y = 0; y < h; y++) {

179 for (x = 0; x < w; x++) {

180 int v = src[x + y * stride] - ref[x + y * stride];

181 block[0][x + w * y] = v;

182 best_score += v * v;

183 block_sum[0] += v;

184 }

185 }

186 }

187

188 best_count = 0;

189 best_score -= (int)((unsigned)block_sum[0] * block_sum[0] >> (level + 3));

190 best_mean = block_sum[0] + (size >> 1) >> (level + 3);

191

192 if (level < 4) {

193 for (count = 1; count < 7; count++) {

194 int best_vector_score = INT_MAX;

195 int best_vector_sum = -999, best_vector_mean = -999;

196 const int stage = count - 1;

197 const int8_t *vector;

198

199 for (i = 0; i < 16; i++) {

200 int sum = codebook_sum[stage * 16 + i];

201 int sqr, diff, score;

202

203 vector = codebook + stage * size * 16 + i * size;

204 sqr = s->svq1encdsp.ssd_int8_vs_int16(vector, block[stage], size);

205 diff = block_sum[stage] - sum;

206 score = sqr - (diff * (int64_t)diff >> (level + 3)); // FIXME: 64 bits slooow

207 if (score < best_vector_score) {

208 int mean = diff + (size >> 1) >> (level + 3);

209 av_assert2(mean > -300 && mean < 300);

210 mean = av_clip(mean, intra ? 0 : -256, 255);

211 best_vector_score = score;

212 best_vector[stage] = i;

213 best_vector_sum = sum;

214 best_vector_mean = mean;

215 }

216 }

217 av_assert0(best_vector_mean != -999);

218 vector = codebook + stage * size * 16 + best_vector[stage] * size;

219 for (j = 0; j < size; j++)

220 block[stage + 1][j] = block[stage][j] - vector[j];

221 block_sum[stage + 1] = block_sum[stage] - best_vector_sum;

222 best_vector_score += lambda *

223 (+1 + 4 * count +

224 multistage_vlc[1 + count][1]

225 + mean_vlc[best_vector_mean][1]);

226

227 if (best_vector_score < best_score) {

228 best_score = best_vector_score;

229 best_count = count;

230 best_mean = best_vector_mean;

231 }

232 }

233 }

234

235 if (best_mean == -128)

236 best_mean = -127;

237 else if (best_mean == 128)

238 best_mean = 127;

239

240 split = 0;

241 if (best_score > threshold && level) {

242 int score = 0;

243 int offset = level & 1 ? stride * h / 2 : w / 2;

244 PutBitContext backup[6];

245

246 for (i = level - 1; i >= 0; i--)

247 backup[i] = s->reorder_pb[i];

248 score += encode_block(s, src, ref, decoded, stride, level - 1,

249 threshold >> 1, lambda, intra);

250 score += encode_block(s, src + offset, ref + offset, decoded + offset,

251 stride, level - 1, threshold >> 1, lambda, intra);

252 score += lambda;

253

254 if (score < best_score) {

255 best_score = score;

256 split = 1;

257 } else {

258 for (i = level - 1; i >= 0; i--)

259 s->reorder_pb[i] = backup[i];

260 }

261 }

262 if (level > 0)

263 put_bits(&s->reorder_pb[level], 1, split);

264

265 if (!split) {

266 av_assert1(best_mean >= 0 && best_mean < 256 || !intra);

267 av_assert1(best_mean >= -256 && best_mean < 256);

268 av_assert1(best_count >= 0 && best_count < 7);

269 av_assert1(level < 4 || best_count == 0);

270

271 /* output the encoding */

272 put_bits(&s->reorder_pb[level],

273 multistage_vlc[1 + best_count][1],

274 multistage_vlc[1 + best_count][0]);

275 put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],

276 mean_vlc[best_mean][0]);

277

278 for (i = 0; i < best_count; i++) {

279 av_assert2(best_vector[i] >= 0 && best_vector[i] < 16);

280 put_bits(&s->reorder_pb[level], 4, best_vector[i]);

281 }

282

283 for (y = 0; y < h; y++)

284 for (x = 0; x < w; x++)

285 decoded[x + y * stride] = src[x + y * stride] -

286 block[best_count][x + w * y] +

287 best_mean;

288 }

289

290 return best_score;

291 }

292

293 static void init_block_index(MpegEncContext *s){

294 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) + s->mb_x*2;

295 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) + 1 + s->mb_x*2;

296 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) + s->mb_x*2;

297 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) + 1 + s->mb_x*2;

298 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x;

299 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x;

300 }

301

302 static int svq1_encode_plane(SVQ1EncContext *s, int plane,

303 PutBitContext *pb,

304 const unsigned char *src_plane,

305 unsigned char *ref_plane,

306 unsigned char *decoded_plane,

307 int width, int height, int src_stride, int stride)

308 {

309 int x, y;

310 int i;

311 int block_width, block_height;

312 int level;

313 int threshold[6];

314 uint8_t *src = s->scratchbuf + stride * 32;

315 const int lambda = (s->quality * s->quality) >>

316 (2 * FF_LAMBDA_SHIFT);

317

318 /* figure out the acceptable level thresholds in advance */

319 threshold[5] = QUALITY_THRESHOLD;

320 for (level = 4; level >= 0; level--)

321 threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;

322

323 block_width = (width + 15) / 16;

324 block_height = (height + 15) / 16;

325

326 if (s->pict_type == AV_PICTURE_TYPE_P) {

327 s->m.avctx = s->avctx;

328 s->m.current_picture_ptr = &s->m.current_picture;

329 s->m.last_picture_ptr = &s->m.last_picture;

330 s->m.last_picture.f->data[0] = ref_plane;

331 s->m.linesize =

332 s->m.last_picture.f->linesize[0] =

333 s->m.new_picture->linesize[0] =

334 s->m.current_picture.f->linesize[0] = stride;

335 s->m.width = width;

336 s->m.height = height;

337 s->m.mb_width = block_width;

338 s->m.mb_height = block_height;

339 s->m.mb_stride = s->m.mb_width + 1;

340 s->m.b8_stride = 2 * s->m.mb_width + 1;

341 s->m.f_code = 1;

342 s->m.pict_type = s->pict_type;

343 s->m.motion_est = s->motion_est;

344 s->m.me.scene_change_score = 0;

345 // s->m.out_format = FMT_H263;

346 // s->m.unrestricted_mv = 1;

347 s->m.lambda = s->quality;

348 s->m.qscale = s->m.lambda * 139 +

349 FF_LAMBDA_SCALE * 64 >>

350 FF_LAMBDA_SHIFT + 7;

351 s->m.lambda2 = s->m.lambda * s->m.lambda +

352 FF_LAMBDA_SCALE / 2 >>

353 FF_LAMBDA_SHIFT;

354

355 if (!s->motion_val8[plane]) {

356 s->motion_val8[plane] = av_mallocz((s->m.b8_stride *

357 block_height * 2 + 2) *

358 2 * sizeof(int16_t));

359 s->motion_val16[plane] = av_mallocz((s->m.mb_stride *

360 (block_height + 2) + 1) *

361 2 * sizeof(int16_t));

362 if (!s->motion_val8[plane] || !s->motion_val16[plane])

363 return AVERROR(ENOMEM);

364 }

365

366 s->m.mb_type = s->mb_type;

367

368 // dummies, to avoid segfaults

369 s->m.mb_mean = (uint8_t *)s->dummy;

370 s->m.mb_var = (uint16_t *)s->dummy;

371 s->m.mc_mb_var = (uint16_t *)s->dummy;

372 s->m.current_picture.mb_type = s->dummy;

373

374 s->m.current_picture.motion_val[0] = s->motion_val8[plane] + 2;

375 s->m.p_mv_table = s->motion_val16[plane] +

376 s->m.mb_stride + 1;

377 s->m.mecc = s->mecc; // move

378 ff_init_me(&s->m);

379

380 s->m.me.dia_size = s->avctx->dia_size;

381 s->m.first_slice_line = 1;

382 for (y = 0; y < block_height; y++) {

383 s->m.new_picture->data[0] = src - y * 16 * stride; // ugly

384 s->m.mb_y = y;

385

386 for (i = 0; i < 16 && i + 16 * y < height; i++) {

387 memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],

388 width);

389 for (x = width; x < 16 * block_width; x++)

390 src[i * stride + x] = src[i * stride + x - 1];

391 }

392 for (; i < 16 && i + 16 * y < 16 * block_height; i++)

393 memcpy(&src[i * stride], &src[(i - 1) * stride],

394 16 * block_width);

395

396 for (x = 0; x < block_width; x++) {

397 s->m.mb_x = x;

398 init_block_index(&s->m);

399

400 ff_estimate_p_frame_motion(&s->m, x, y);

401 }

402 s->m.first_slice_line = 0;

403 }

404

405 ff_fix_long_p_mvs(&s->m, CANDIDATE_MB_TYPE_INTRA);

406 ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,

407 CANDIDATE_MB_TYPE_INTER, 0);

408 }

409

410 s->m.first_slice_line = 1;

411 for (y = 0; y < block_height; y++) {

412 for (i = 0; i < 16 && i + 16 * y < height; i++) {

413 memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],

414 width);

415 for (x = width; x < 16 * block_width; x++)

416 src[i * stride + x] = src[i * stride + x - 1];

417 }

418 for (; i < 16 && i + 16 * y < 16 * block_height; i++)

419 memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);

420

421 s->m.mb_y = y;

422 for (x = 0; x < block_width; x++) {

423 uint8_t reorder_buffer[2][6][7 * 32];

424 int count[2][6];

425 int offset = y * 16 * stride + x * 16;

426 uint8_t *decoded = decoded_plane + offset;

427 const uint8_t *ref = ref_plane + offset;

428 int score[4] = { 0, 0, 0, 0 }, best;

429 uint8_t *temp = s->scratchbuf;

430

431 if (put_bytes_left(pb, 0) < 3000) { // FIXME: check size

432 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

433 return -1;

434 }

435

436 s->m.mb_x = x;

437 init_block_index(&s->m);

438

439 if (s->pict_type == AV_PICTURE_TYPE_I ||

440 (s->m.mb_type[x + y * s->m.mb_stride] &

441 CANDIDATE_MB_TYPE_INTRA)) {

442 for (i = 0; i < 6; i++)

443 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],

444 7 * 32);

445 if (s->pict_type == AV_PICTURE_TYPE_P) {

446 put_bits(&s->reorder_pb[5], SVQ1_BLOCK_INTRA_LEN, SVQ1_BLOCK_INTRA_CODE);

447 score[0] = SVQ1_BLOCK_INTRA_LEN * lambda;

448 }

449 score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,

450 5, 64, lambda, 1);

451 for (i = 0; i < 6; i++) {

452 count[0][i] = put_bits_count(&s->reorder_pb[i]);

453 flush_put_bits(&s->reorder_pb[i]);

454 }

455 } else

456 score[0] = INT_MAX;

457

458 best = 0;

459

460 if (s->pict_type == AV_PICTURE_TYPE_P) {

461 int mx, my, pred_x, pred_y, dxy;

462 int16_t *motion_ptr;

463

464 motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);

465 if (s->m.mb_type[x + y * s->m.mb_stride] &

466 CANDIDATE_MB_TYPE_INTER) {

467 for (i = 0; i < 6; i++)

468 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],

469 7 * 32);

470

471 put_bits(&s->reorder_pb[5], SVQ1_BLOCK_INTER_LEN, SVQ1_BLOCK_INTER_CODE);

472

473 s->m.pb = s->reorder_pb[5];

474 mx = motion_ptr[0];

475 my = motion_ptr[1];

476 av_assert1(mx >= -32 && mx <= 31);

477 av_assert1(my >= -32 && my <= 31);

478 av_assert1(pred_x >= -32 && pred_x <= 31);

479 av_assert1(pred_y >= -32 && pred_y <= 31);

480 ff_h263_encode_motion(&s->m.pb, mx - pred_x, 1);

481 ff_h263_encode_motion(&s->m.pb, my - pred_y, 1);

482 s->reorder_pb[5] = s->m.pb;

483 score[1] += lambda * put_bits_count(&s->reorder_pb[5]);

484

485 dxy = (mx & 1) + 2 * (my & 1);

486

487 s->hdsp.put_pixels_tab[0][dxy](temp + 16*stride,

488 ref + (mx >> 1) +

489 stride * (my >> 1),

490 stride, 16);

491

492 score[1] += encode_block(s, src + 16 * x, temp + 16*stride,

493 decoded, stride, 5, 64, lambda, 0);

494 best = score[1] <= score[0];

495

496 score[2] = s->mecc.sse[0](NULL, src + 16 * x, ref,

497 stride, 16);

498 score[2] += SVQ1_BLOCK_SKIP_LEN * lambda;

499 if (score[2] < score[best] && mx == 0 && my == 0) {

500 best = 2;

501 s->hdsp.put_pixels_tab[0][0](decoded, ref, stride, 16);

502 put_bits(pb, SVQ1_BLOCK_SKIP_LEN, SVQ1_BLOCK_SKIP_CODE);

503 }

504 }

505

506 if (best == 1) {

507 for (i = 0; i < 6; i++) {

508 count[1][i] = put_bits_count(&s->reorder_pb[i]);

509 flush_put_bits(&s->reorder_pb[i]);

510 }

511 } else {

512 motion_ptr[0] =

513 motion_ptr[1] =

514 motion_ptr[2] =

515 motion_ptr[3] =

516 motion_ptr[0 + 2 * s->m.b8_stride] =

517 motion_ptr[1 + 2 * s->m.b8_stride] =

518 motion_ptr[2 + 2 * s->m.b8_stride] =

519 motion_ptr[3 + 2 * s->m.b8_stride] = 0;

520 }

521 }

522

523 s->rd_total += score[best];

524

525 if (best != 2)

526 for (i = 5; i >= 0; i--)

527 ff_copy_bits(pb, reorder_buffer[best][i],

528 count[best][i]);

529 if (best == 0)

530 s->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16);

531 }

532 s->m.first_slice_line = 0;

533 }

534 return 0;

535 }

536

537 static av_cold int svq1_encode_end(AVCodecContext *avctx)

538 {

539 SVQ1EncContext *const s = avctx->priv_data;

540 int i;

541

542 if (avctx->frame_num)

543 av_log(avctx, AV_LOG_DEBUG, "RD: %f\n",

544 s->rd_total / (double)(avctx->width * avctx->height *

545 avctx->frame_num));

546

547 s->m.mb_type = NULL;

548 ff_mpv_common_end(&s->m);

549

550 av_freep(&s->m.me.scratchpad);

551 av_freep(&s->m.me.map);

552 av_freep(&s->mb_type);

553 av_freep(&s->dummy);

554 av_freep(&s->scratchbuf);

555

556 for (i = 0; i < 3; i++) {

557 av_freep(&s->motion_val8[i]);

558 av_freep(&s->motion_val16[i]);

559 }

560

561 av_frame_free(&s->current_picture);

562 av_frame_free(&s->last_picture);

563 av_frame_free(&s->m.new_picture);

564

565 return 0;

566 }

567

568 static av_cold int write_ident(AVCodecContext *avctx, const char *ident)

569 {

570 int size = strlen(ident);

571 avctx->extradata = av_malloc(size + 8);

572 if (!avctx->extradata)

573 return AVERROR(ENOMEM);

574 AV_WB32(avctx->extradata, size + 8);

575 AV_WL32(avctx->extradata + 4, MKTAG('S', 'V', 'Q', '1'));

576 memcpy(avctx->extradata + 8, ident, size);

577 avctx->extradata_size = size + 8;

578 return 0;

579 }

580

581 static av_cold int svq1_encode_init(AVCodecContext *avctx)

582 {

583 SVQ1EncContext *const s = avctx->priv_data;

584 int ret;

585

586 if (avctx->width >= 4096 || avctx->height >= 4096) {

587 av_log(avctx, AV_LOG_ERROR, "Dimensions too large, maximum is 4095x4095\n");

588 return AVERROR(EINVAL);

589 }

590

591 ff_hpeldsp_init(&s->hdsp, avctx->flags);

592 ff_me_cmp_init(&s->mecc, avctx);

593 ff_mpegvideoencdsp_init(&s->m.mpvencdsp, avctx);

594

595 s->current_picture = av_frame_alloc();

596 s->last_picture = av_frame_alloc();

597 if (!s->current_picture || !s->last_picture) {

598 return AVERROR(ENOMEM);

599 }

600

601 s->frame_width = avctx->width;

602 s->frame_height = avctx->height;

603

604 s->y_block_width = (s->frame_width + 15) / 16;

605 s->y_block_height = (s->frame_height + 15) / 16;

606

607 s->c_block_width = (s->frame_width / 4 + 15) / 16;

608 s->c_block_height = (s->frame_height / 4 + 15) / 16;

609

610 s->avctx = avctx;

611 s->m.avctx = avctx;

612

613 if ((ret = ff_mpv_common_init(&s->m)) < 0) {

614 return ret;

615 }

616

617 s->m.picture_structure = PICT_FRAME;

618 s->m.me.temp =

619 s->m.me.scratchpad = av_mallocz((avctx->width + 64) *

620 2 * 16 * 2 * sizeof(uint8_t));

621 s->mb_type = av_mallocz((s->y_block_width + 1) *

622 s->y_block_height * sizeof(int16_t));

623 s->dummy = av_mallocz((s->y_block_width + 1) *

624 s->y_block_height * sizeof(int32_t));

625 s->m.me.map = av_mallocz(2 * ME_MAP_SIZE * sizeof(*s->m.me.map));

626 s->m.new_picture = av_frame_alloc();

627

628 if (!s->m.me.scratchpad || !s->m.me.map ||

629 !s->mb_type || !s->dummy || !s->m.new_picture)

630 return AVERROR(ENOMEM);

631 s->m.me.score_map = s->m.me.map + ME_MAP_SIZE;

632

633 ff_svq1enc_init(&s->svq1encdsp);

634

635 ff_h263_encode_init(&s->m); // mv_penalty

636

637 return write_ident(avctx, s->avctx->flags & AV_CODEC_FLAG_BITEXACT ? "Lavc" : LIBAVCODEC_IDENT);

638 }

639

640 static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

641 const AVFrame *pict, int *got_packet)

642 {

643 SVQ1EncContext *const s = avctx->priv_data;

644 PutBitContext pb;

645 int i, ret;

646

647 ret = ff_alloc_packet(avctx, pkt, s->y_block_width * s->y_block_height *

648 MAX_MB_BYTES * 3 + FF_INPUT_BUFFER_MIN_SIZE);

649 if (ret < 0)

650 return ret;

651

652 if (avctx->pix_fmt != AV_PIX_FMT_YUV410P) {

653 av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");

654 return -1;

655 }

656

657 if (!s->current_picture->data[0]) {

658 if ((ret = ff_encode_alloc_frame(avctx, s->current_picture)) < 0) {

659 return ret;

660 }

661 }

662 if (!s->last_picture->data[0]) {

663 ret = ff_encode_alloc_frame(avctx, s->last_picture);

664 if (ret < 0)

665 return ret;

666 }

667 if (!s->scratchbuf) {

668 s->scratchbuf = av_malloc_array(s->current_picture->linesize[0], 16 * 3);

669 if (!s->scratchbuf)

670 return AVERROR(ENOMEM);

671 }

672

673 FFSWAP(AVFrame*, s->current_picture, s->last_picture);

674

675 if (avctx->gop_size && (avctx->frame_num % avctx->gop_size))

676 s->pict_type = AV_PICTURE_TYPE_P;

677 else

678 s->pict_type = AV_PICTURE_TYPE_I;

679 s->quality = pict->quality;

680

681 ff_side_data_set_encoder_stats(pkt, pict->quality, NULL, 0, s->pict_type);

682

683 init_put_bits(&pb, pkt->data, pkt->size);

684 svq1_write_header(s, &pb, s->pict_type);

685 for (i = 0; i < 3; i++) {

686 int ret = svq1_encode_plane(s, i, &pb,

687 pict->data[i],

688 s->last_picture->data[i],

689 s->current_picture->data[i],

690 s->frame_width / (i ? 4 : 1),

691 s->frame_height / (i ? 4 : 1),

692 pict->linesize[i],

693 s->current_picture->linesize[i]);

694 emms_c();

695 if (ret < 0) {

696 int j;

697 for (j = 0; j < i; j++) {

698 av_freep(&s->motion_val8[j]);

699 av_freep(&s->motion_val16[j]);

700 }

701 av_freep(&s->scratchbuf);

702 return -1;

703 }

704 }

705

706 // align_put_bits(&pb);

707 while (put_bits_count(&pb) & 31)

708 put_bits(&pb, 1, 0);

709

710 flush_put_bits(&pb);

711

712 pkt->size = put_bytes_output(&pb);

713 if (s->pict_type == AV_PICTURE_TYPE_I)

714 pkt->flags |= AV_PKT_FLAG_KEY;

715 *got_packet = 1;

716

717 return 0;

718 }

719

720 #define OFFSET(x) offsetof(struct SVQ1EncContext, x)

721 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

722 static const AVOption options[] = {

723 { "motion-est", "Motion estimation algorithm", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, VE, .unit = "motion-est"},

724 { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" },

725 { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" },

726 { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" },

727

728 { NULL },

729 };

730

731 static const AVClass svq1enc_class = {

732 .class_name = "svq1enc",

733 .item_name = av_default_item_name,

734 .option = options,

735 .version = LIBAVUTIL_VERSION_INT,

736 };

737

738 const FFCodec ff_svq1_encoder = {

739 .p.name = "svq1",

740 CODEC_LONG_NAME("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),

741 .p.type = AVMEDIA_TYPE_VIDEO,

742 .p.id = AV_CODEC_ID_SVQ1,

743 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

744 .priv_data_size = sizeof(SVQ1EncContext),

745 .p.priv_class = &svq1enc_class,

746 .init = svq1_encode_init,

747 FF_CODEC_ENCODE_CB(svq1_encode_frame),

748 .close = svq1_encode_end,

749 .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,

750 AV_PIX_FMT_NONE },

751 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

752 };

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:38

ff_mpv_common_init

av_cold int ff_mpv_common_init(MpegEncContext *s)

init common structure for both encoder and decoder.

Definition: mpegvideo.c:681

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

level

uint8_t level

Definition: svq3.c:204

av_clip

#define av_clip

Definition: common.h:98

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

FF_LAMBDA_SCALE

#define FF_LAMBDA_SCALE

Definition: avutil.h:226

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

LIBAVCODEC_IDENT

#define LIBAVCODEC_IDENT

Definition: version.h:43

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:424

mem_internal.h

svq1enc_cb.h

put_bytes_output

static int put_bytes_output(const PutBitContext *s)

Definition: put_bits.h:89

SVQ1EncContext::motion_est

int motion_est

Definition: svq1enc.c:98

ff_fix_long_p_mvs

void ff_fix_long_p_mvs(MpegEncContext *s, int type)

Definition: motion_est.c:1655

FF_ME_EPZS

#define FF_ME_EPZS

Definition: motion_est.h:41

write_ident

static av_cold int write_ident(AVCodecContext *avctx, const char *ident)

Definition: svq1enc.c:568

ff_side_data_set_encoder_stats

int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)

Definition: avpacket.c:607

options

static const AVOption options[]

Definition: svq1enc.c:722

SVQ1_BLOCK_INTRA_CODE

#define SVQ1_BLOCK_INTRA_CODE

Definition: svq1.h:51

ff_svq1_inter_codebooks

const FF_VISIBILITY_PUSH_HIDDEN int8_t *const ff_svq1_inter_codebooks[6]

Definition: svq1_cb.h:776

AVPictureType

Definition: avutil.h:277

SVQ1EncContext

Definition: svq1enc.c:57

int64_t

long long int64_t

Definition: coverity.c:34

block_sum

static int block_sum(const uint8_t *block, int w, int h, int linesize)

Definition: mobiclip.c:812

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:62

svq1_encode_frame

static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)

Definition: svq1enc.c:640

h263enc.h

ff_svq1_intra_codebooks

const int8_t *const ff_svq1_intra_codebooks[6]

Definition: svq1_cb.h:1519

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:130

AVFrame

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

Definition: frame.h:344

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:222

uint8_t w

Definition: llviddspenc.c:38

SVQ1EncContext::frame_width

int frame_width

Definition: svq1enc.c:76

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:522

#define VE

Definition: svq1enc.c:721

AVOption

AVOption.

Definition: opt.h:346

encode.h

FFCodec

Definition: codec_internal.h:127

version.h

SVQ1EncContext::pict_type

enum AVPictureType pict_type

Definition: svq1enc.c:69

SVQ1_BLOCK_SKIP_CODE

#define SVQ1_BLOCK_SKIP_CODE

Definition: svq1.h:47

mpegvideo.h

sqr

static double sqr(double in)

Definition: af_afwtdn.c:871

FF_LAMBDA_SHIFT

#define FF_LAMBDA_SHIFT

Definition: avutil.h:225

CANDIDATE_MB_TYPE_INTER

#define CANDIDATE_MB_TYPE_INTER

Definition: mpegutils.h:98

mpegutils.h

SVQ1EncContext::encoded_block_levels

int16_t encoded_block_levels[6][7][256]

Definition: svq1enc.c:87

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:577

svq1_inter_codebook_sum

static const int8_t svq1_inter_codebook_sum[4][16 *6]

Definition: svq1enc_cb.h:32

FF_INPUT_BUFFER_MIN_SIZE

#define FF_INPUT_BUFFER_MIN_SIZE

Used by some encoders as upper bound for the length of headers.

Definition: encode.h:33

svq1encdsp.h

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:365

SVQ1EncContext::c_block_width

int c_block_width

Definition: svq1enc.c:84

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

ff_svq1_intra_multistage_vlc

const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]

Definition: svq1_vlc.h:33

ff_mpegvideoencdsp_init

av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)

Definition: mpegvideoencdsp.c:232

ff_svq1_inter_mean_vlc

const uint16_t ff_svq1_inter_mean_vlc[512][2]

Definition: svq1_vlc.h:136

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

ff_match_2uint16

int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)

Return the index into tab at which {a,b} match elements {[0],[1]} of tab.

Definition: utils.c:834

ff_h263_pred_motion

int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)

Definition: h263.c:190

SVQ1EncContext::svq1encdsp

SVQ1EncDSPContext svq1encdsp

Definition: svq1enc.c:100

ff_me_cmp_init

av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)

Definition: me_cmp.c:1008

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:502

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:296

put_bytes_left

static int put_bytes_left(const PutBitContext *s, int round_up)

Definition: put_bits.h:135

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:118

ff_mpv_common_end

void ff_mpv_common_end(MpegEncContext *s)

Definition: mpegvideo.c:782

avassert.h

pkt

AVPacket * pkt

Definition: movenc.c:59

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

svq1_encode_plane

static int svq1_encode_plane(SVQ1EncContext *s, int plane, PutBitContext *pb, const unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane, int width, int height, int src_stride, int stride)

Definition: svq1enc.c:302

SVQ1EncContext::last_picture

AVFrame * last_picture

Definition: svq1enc.c:66

emms_c

#define emms_c()

Definition: emms.h:63

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:524

SVQ1EncContext::y_block_height

int y_block_height

Definition: svq1enc.c:81

width

#define width

MAX_MB_BYTES

#define MAX_MB_BYTES

Definition: mpegutils.h:40

SVQ1_BLOCK_SKIP_LEN

#define SVQ1_BLOCK_SKIP_LEN

Definition: svq1.h:48

#define s(width, name)

Definition: cbs_vp9.c:198

AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...

Definition: codec.h:159

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

SVQ1EncContext::frame_height

int frame_height

Definition: svq1enc.c:77

SVQ1_BLOCK_INTRA_LEN

#define SVQ1_BLOCK_INTRA_LEN

Definition: svq1.h:52

THRESHOLD_MULTIPLIER

#define THRESHOLD_MULTIPLIER

Definition: svq1enc.c:138

ff_svq1_encoder

const FFCodec ff_svq1_encoder

Definition: svq1enc.c:738

svq1_write_header

static void svq1_write_header(SVQ1EncContext *s, PutBitContext *pb, int frame_type)

Definition: svq1enc.c:103

SVQ1EncContext::m

MpegEncContext m

Definition: svq1enc.c:61

PutBitContext

Definition: put_bits.h:50

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

ff_hpeldsp_init

av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)

Definition: hpeldsp.c:338

MECmpContext

Definition: me_cmp.h:55

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

SVQ1EncContext::current_picture

AVFrame * current_picture

Definition: svq1enc.c:65

ff_svq1enc_init

static void ff_svq1enc_init(SVQ1EncDSPContext *c)

Definition: svq1encdsp.h:47

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:279

SVQ1EncContext::c_block_height

int c_block_height

Definition: svq1enc.c:85

ME_MAP_SIZE

#define ME_MAP_SIZE

Definition: motion_est.h:38

FF_ME_XONE

#define FF_ME_XONE

Definition: motion_est.h:42

AV_WB32

#define AV_WB32(p, v)

Definition: intreadwrite.h:417

svq1_encode_end

static av_cold int svq1_encode_end(AVCodecContext *avctx)

Definition: svq1enc.c:537

SVQ1EncContext::rd_total

int64_t rd_total

Definition: svq1enc.c:94

HpelDSPContext

Half-pel DSP context.

Definition: hpeldsp.h:45

ff_encode_alloc_frame

int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame)

Allocate buffers for a frame.

Definition: encode.c:794

SVQ1EncContext::dummy

uint32_t * dummy

Definition: svq1enc.c:90

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

SVQ1EncContext::quality

int quality

Definition: svq1enc.c:70

AVPacket::size

int size

Definition: packet.h:523

AVCodecContext::gop_size

int gop_size

the number of pictures in a group of pictures, or 0 for intra_only

Definition: avcodec.h:1031

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:109

AVFrame::quality

int quality

quality (between 1 (good) and FF_LAMBDA_MAX (bad))

Definition: frame.h:476

OFFSET

#define OFFSET(x)

Definition: svq1enc.c:720

init_block_index

static void init_block_index(MpegEncContext *s)

Definition: svq1enc.c:293

size

int size

Definition: twinvq_data.h:10344

SVQ1EncContext::reorder_pb

PutBitContext reorder_pb[6]

Definition: svq1enc.c:74

SVQ1EncContext::mb_type

uint16_t * mb_type

Definition: svq1enc.c:89

frame.h

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:164

split

static char * split(char *message, char delim)

Definition: af_channelmap.c:80

height

#define height

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

SVQ1_BLOCK_INTER_CODE

#define SVQ1_BLOCK_INTER_CODE

Definition: svq1.h:49

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:528

SVQ1EncContext::avctx

AVCodecContext * avctx

Definition: svq1enc.c:62

AV_CODEC_ID_SVQ1

@ AV_CODEC_ID_SVQ1

Definition: codec_id.h:74

emms.h

QUALITY_THRESHOLD

#define QUALITY_THRESHOLD

Definition: svq1enc.c:137

av_assert2

#define av_assert2(cond)

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

Definition: avassert.h:67

SVQ1_BLOCK_INTER_LEN

#define SVQ1_BLOCK_INTER_LEN

Definition: svq1.h:50

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

Definition: cbs_h2645.c:255

put_bits_count

static int put_bits_count(PutBitContext *s)

Definition: put_bits.h:80

frame_type

Definition: jpeg2000_parser.c:31

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:523

SVQ1EncContext::mecc

MECmpContext mecc

Definition: svq1enc.c:63

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

av_assert1

#define av_assert1(cond)

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

Definition: avassert.h:56

ff_h263_encode_init

void ff_h263_encode_init(MpegEncContext *s)

Definition: ituh263enc.c:816

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:254

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

SVQ1EncContext::motion_val8

int16_t(*[3] motion_val8)[2]

Definition: svq1enc.c:91

ff_init_me

int ff_init_me(MpegEncContext *s)

Definition: motion_est.c:308

AVCodecContext::height

int height

Definition: avcodec.h:618

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:657

SVQ1EncContext::hdsp

HpelDSPContext hdsp

Definition: svq1enc.c:64

svq1_intra_codebook_sum

static const int8_t svq1_intra_codebook_sum[4][16 *6]

Definition: svq1enc_cb.h:59

avcodec.h

stride

#define stride

Definition: h264pred_template.c:537

ff_svq1_inter_multistage_vlc

const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]

Definition: svq1_vlc.h:50

AVCodecContext::frame_num

int64_t frame_num

Frame counter, set by libavcodec.

Definition: avcodec.h:2030

SVQ1EncContext::y_block_width

int y_block_width

Definition: svq1enc.c:80

SVQ1EncDSPContext

Definition: svq1encdsp.h:28

ret

Definition: filter_design.txt:187

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

ff_copy_bits

void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)

Copy the content of src to the bitstream.

Definition: bitstream.c:49

me_cmp.h

SVQ1EncContext::motion_val16

int16_t(*[3] motion_val16)[2]

Definition: svq1enc.c:92

ff_fix_long_mvs

void ff_fix_long_mvs(MpegEncContext *s, uint8_t *field_select_table, int field_select, int16_t(*mv_table)[2], int f_code, int type, int truncate)

Definition: motion_est.c:1704

AVCodecContext

main external API structure.

Definition: avcodec.h:445

ff_estimate_p_frame_motion

void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)

Definition: motion_est.c:890

FF_MPV_OPT_FLAGS

#define FF_MPV_OPT_FLAGS

Definition: mpegvideoenc.h:64

ff_svq1_intra_mean_vlc

const uint16_t ff_svq1_intra_mean_vlc[256][2]

Definition: svq1_vlc.h:67

CANDIDATE_MB_TYPE_INTRA

#define CANDIDATE_MB_TYPE_INTRA

Definition: mpegutils.h:97

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:235

svq1.h

ref

static int ref[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:112

temp

else temp

Definition: vf_mcdeint.c:263

mean

static float mean(const float *input, int size)

Definition: vf_nnedi.c:862

encode_block

static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, unsigned level, int threshold, int lambda, int intra)

Definition: svq1enc.c:140

svq1enc_class

static const AVClass svq1enc_class

Definition: svq1enc.c:731

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:280

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

packet_internal.h