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 "libavutil/mem.h"

31 #include "avcodec.h"

32 #include "codec_internal.h"

33 #include "encode.h"

34 #include "hpeldsp.h"

35 #include "me_cmp.h"

36 #include "mpegvideo.h"

37 #include "h263.h"

38 #include "h263enc.h"

39 #include "internal.h"

40 #include "mpegutils.h"

41 #include "packet_internal.h"

42 #include "put_bits.h"

43 #include "svq1.h"

44 #include "svq1encdsp.h"

45 #include "svq1enc_cb.h"

46 #include "version.h"

48 #include "libavutil/avassert.h"

49 #include "libavutil/frame.h"

50 #include "libavutil/mem_internal.h"

52 // Workaround for GCC bug 102513

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

54 && !defined(__clang__) && !defined(__INTEL_COMPILER)

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

56 #endif

58 typedef struct SVQ1EncContext {

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

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

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

62 MpegEncContext m;

63 AVCodecContext *avctx;

64 MECmpContext mecc;

65 HpelDSPContext hdsp;

66 AVFrame *current_picture;

67 AVFrame *last_picture;

69 /* Some compression statistics */

70 enum AVPictureType pict_type;

71 int quality;

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

74 * everything is slower and more complex */

75 PutBitContext reorder_pb[6];

77 int frame_width;

78 int frame_height;

80 /* Y plane block dimensions */

81 int y_block_width;

82 int y_block_height;

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

85 int c_block_width;

86 int c_block_height;

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

90 uint16_t *mb_type;

91 uint32_t *dummy;

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

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

95 int64_t rd_total;

97 uint8_t *scratchbuf;

99 int motion_est;

100

101 SVQ1EncDSPContext svq1encdsp;

102 } SVQ1EncContext;

103

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

105 {

106 int i;

107

108 /* frame code */

109 put_bits(pb, 22, 0x20);

110

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

112 put_bits(pb, 8, 0x00);

113

114 /* frame type */

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

116

117 if (frame_type == AV_PICTURE_TYPE_I) {

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

119 /* no embedded string either */

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

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

122

123 i = ff_match_2uint16(ff_svq1_frame_size_table,

124 FF_ARRAY_ELEMS(ff_svq1_frame_size_table),

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

126 put_bits(pb, 3, i);

127

128 if (i == 7) {

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

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

131 }

132 }

133

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

135 put_bits(pb, 2, 0);

136 }

137

138 #define QUALITY_THRESHOLD 100

139 #define THRESHOLD_MULTIPLIER 0.6

140

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

142 uint8_t *decoded, int stride, unsigned level,

143 int threshold, int lambda, int intra)

144 {

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

146 int best_vector[6];

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

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

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

150 int size = w * h;

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

152 const int8_t *codebook_sum, *codebook;

153 const uint16_t(*mean_vlc)[2];

154 const uint8_t(*multistage_vlc)[2];

155

156 best_score = 0;

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

158 if (intra) {

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

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

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

162 codebook = ff_svq1_intra_codebooks[level];

163 mean_vlc = ff_svq1_intra_mean_vlc;

164 multistage_vlc = ff_svq1_intra_multistage_vlc[level];

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

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

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

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

169 best_score += v * v;

170 block_sum[0] += v;

171 }

172 }

173 } else {

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

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

176 codebook = ff_svq1_inter_codebooks[level];

177 mean_vlc = ff_svq1_inter_mean_vlc + 256;

178 multistage_vlc = ff_svq1_inter_multistage_vlc[level];

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

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

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

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

183 best_score += v * v;

184 block_sum[0] += v;

185 }

186 }

187 }

188

189 best_count = 0;

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

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

192

193 if (level < 4) {

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

195 int best_vector_score = INT_MAX;

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

197 const int stage = count - 1;

198 const int8_t *vector;

199

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

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

202 int sqr, diff, score;

203

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

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

206 diff = block_sum[stage] - sum;

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

208 if (score < best_vector_score) {

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

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

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

212 best_vector_score = score;

213 best_vector[stage] = i;

214 best_vector_sum = sum;

215 best_vector_mean = mean;

216 }

217 }

218 av_assert0(best_vector_mean != -999);

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

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

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

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

223 best_vector_score += lambda *

224 (+1 + 4 * count +

225 multistage_vlc[1 + count][1]

226 + mean_vlc[best_vector_mean][1]);

227

228 if (best_vector_score < best_score) {

229 best_score = best_vector_score;

230 best_count = count;

231 best_mean = best_vector_mean;

232 }

233 }

234 }

235

236 if (best_mean == -128)

237 best_mean = -127;

238 else if (best_mean == 128)

239 best_mean = 127;

240

241 split = 0;

242 if (best_score > threshold && level) {

243 int score = 0;

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

245 PutBitContext backup[6];

246

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

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

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

250 threshold >> 1, lambda, intra);

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

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

253 score += lambda;

254

255 if (score < best_score) {

256 best_score = score;

257 split = 1;

258 } else {

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

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

261 }

262 }

263 if (level > 0)

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

265

266 if (!split) {

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

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

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

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

271

272 /* output the encoding */

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

274 multistage_vlc[1 + best_count][1],

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

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

277 mean_vlc[best_mean][0]);

278

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

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

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

282 }

283

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

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

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

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

288 best_mean;

289 }

290

291 return best_score;

292 }

293

294 static void init_block_index(MpegEncContext *s){

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

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

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

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

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

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

301 }

302

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

304 PutBitContext *pb,

305 const unsigned char *src_plane,

306 unsigned char *ref_plane,

307 unsigned char *decoded_plane,

308 int width, int height, int src_stride, int stride)

309 {

310 int x, y;

311 int i;

312 int block_width, block_height;

313 int level;

314 int threshold[6];

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

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

317 (2 * FF_LAMBDA_SHIFT);

318

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

320 threshold[5] = QUALITY_THRESHOLD;

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

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

323

324 block_width = (width + 15) / 16;

325 block_height = (height + 15) / 16;

326

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

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

329 s->m.last_pic.data[0] = ref_plane;

330 s->m.linesize =

331 s->m.last_pic.linesize[0] =

332 s->m.new_pic->linesize[0] =

333 s->m.cur_pic.linesize[0] = stride;

334 s->m.width = width;

335 s->m.height = height;

336 s->m.mb_width = block_width;

337 s->m.mb_height = block_height;

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

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

340 s->m.f_code = 1;

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

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

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

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

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

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

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

348 FF_LAMBDA_SCALE * 64 >>

349 FF_LAMBDA_SHIFT + 7;

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

351 FF_LAMBDA_SCALE / 2 >>

352 FF_LAMBDA_SHIFT;

353

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

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

356 block_height * 2 + 2) *

357 2 * sizeof(int16_t));

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

359 (block_height + 2) + 1) *

360 2 * sizeof(int16_t));

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

362 return AVERROR(ENOMEM);

363 }

364

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

366

367 // dummies, to avoid segfaults

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

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

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

371 s->m.cur_pic.mb_type = s->dummy;

372

373 s->m.cur_pic.motion_val[0] = s->motion_val8[plane] + 2;

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

375 s->m.mb_stride + 1;

376 ff_me_init_pic(&s->m);

377

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

379 s->m.first_slice_line = 1;

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

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

382 s->m.mb_y = y;

383

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

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

386 width);

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

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

389 }

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

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

392 16 * block_width);

393

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

395 s->m.mb_x = x;

396 init_block_index(&s->m);

397

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

399 }

400 s->m.first_slice_line = 0;

401 }

402

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

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

405 CANDIDATE_MB_TYPE_INTER, 0);

406 }

407

408 s->m.first_slice_line = 1;

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

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

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

412 width);

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

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

415 }

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

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

418

419 s->m.mb_y = y;

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

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

422 int count[2][6];

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

424 uint8_t *decoded = decoded_plane + offset;

425 const uint8_t *ref = ref_plane + offset;

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

427 uint8_t *temp = s->scratchbuf;

428

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

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

431 return -1;

432 }

433

434 s->m.mb_x = x;

435 init_block_index(&s->m);

436

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

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

439 CANDIDATE_MB_TYPE_INTRA)) {

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

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

442 7 * 32);

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

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

445 score[0] = SVQ1_BLOCK_INTRA_LEN * lambda;

446 }

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

448 5, 64, lambda, 1);

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

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

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

452 }

453 } else

454 score[0] = INT_MAX;

455

456 best = 0;

457

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

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

460 int16_t *motion_ptr;

461

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

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

464 CANDIDATE_MB_TYPE_INTER) {

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

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

467 7 * 32);

468

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

470

471 mx = motion_ptr[0];

472 my = motion_ptr[1];

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

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

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

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

477 ff_h263_encode_motion(&s->reorder_pb[5], mx - pred_x, 1);

478 ff_h263_encode_motion(&s->reorder_pb[5], my - pred_y, 1);

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

480

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

482

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

484 ref + (mx >> 1) +

485 stride * (my >> 1),

486 stride, 16);

487

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

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

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

491

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

493 stride, 16);

494 score[2] += SVQ1_BLOCK_SKIP_LEN * lambda;

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

496 best = 2;

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

498 put_bits(pb, SVQ1_BLOCK_SKIP_LEN, SVQ1_BLOCK_SKIP_CODE);

499 }

500 }

501

502 if (best == 1) {

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

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

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

506 }

507 } else {

508 motion_ptr[0] =

509 motion_ptr[1] =

510 motion_ptr[2] =

511 motion_ptr[3] =

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

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

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

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

516 }

517 }

518

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

520

521 if (best != 2)

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

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

524 count[best][i]);

525 if (best == 0)

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

527 }

528 s->m.first_slice_line = 0;

529 }

530 return 0;

531 }

532

533 static av_cold int svq1_encode_end(AVCodecContext *avctx)

534 {

535 SVQ1EncContext *const s = avctx->priv_data;

536 int i;

537

538 if (avctx->frame_num)

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

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

541 avctx->frame_num));

542

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

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

545 av_freep(&s->mb_type);

546 av_freep(&s->dummy);

547 av_freep(&s->scratchbuf);

548

549 s->m.mb_type = NULL;

550 ff_mpv_common_end(&s->m);

551

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

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

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

555 }

556

557 av_frame_free(&s->current_picture);

558 av_frame_free(&s->last_picture);

559 av_frame_free(&s->m.new_pic);

560

561 return 0;

562 }

563

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

565 {

566 int size = strlen(ident);

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

568 if (!avctx->extradata)

569 return AVERROR(ENOMEM);

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

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

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

573 avctx->extradata_size = size + 8;

574 return 0;

575 }

576

577 static av_cold int svq1_encode_init(AVCodecContext *avctx)

578 {

579 SVQ1EncContext *const s = avctx->priv_data;

580 int ret;

581

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

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

584 return AVERROR(EINVAL);

585 }

586

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

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

589 ret = ff_me_init(&s->m.me, avctx, &s->mecc, 0);

590 if (ret < 0)

591 return ret;

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

593

594 s->current_picture = av_frame_alloc();

595 s->last_picture = av_frame_alloc();

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

597 return AVERROR(ENOMEM);

598 }

599

600 s->frame_width = avctx->width;

601 s->frame_height = avctx->height;

602

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

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

605

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

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

608

609 s->avctx = avctx;

610 s->m.avctx = avctx;

611

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

613 return ret;

614 }

615

616 s->m.picture_structure = PICT_FRAME;

617 s->m.me.temp =

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

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

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

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

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

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

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

625 s->m.new_pic = av_frame_alloc();

626

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

628 !s->mb_type || !s->dummy || !s->m.new_pic)

629 return AVERROR(ENOMEM);

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

631

632 ff_svq1enc_init(&s->svq1encdsp);

633

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

635

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

637 }

638

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

640 const AVFrame *pict, int *got_packet)

641 {

642 SVQ1EncContext *const s = avctx->priv_data;

643 PutBitContext pb;

644 int i, ret;

645

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

647 MAX_MB_BYTES * 3 + FF_INPUT_BUFFER_MIN_SIZE);

648 if (ret < 0)

649 return ret;

650

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

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

653 return -1;

654 }

655

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

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

658 return ret;

659 }

660 }

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

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

663 if (ret < 0)

664 return ret;

665 }

666 if (!s->scratchbuf) {

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

668 if (!s->scratchbuf)

669 return AVERROR(ENOMEM);

670 }

671

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

673

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

675 s->pict_type = AV_PICTURE_TYPE_P;

676 else

677 s->pict_type = AV_PICTURE_TYPE_I;

678 s->quality = pict->quality;

679

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

681

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

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

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

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

686 pict->data[i],

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

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

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

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

691 pict->linesize[i],

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

693 emms_c();

694 if (ret < 0) {

695 int j;

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

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

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

699 }

700 av_freep(&s->scratchbuf);

701 return -1;

702 }

703 }

704

705 // align_put_bits(&pb);

706 while (put_bits_count(&pb) & 31)

707 put_bits(&pb, 1, 0);

708

709 flush_put_bits(&pb);

710

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

712 if (s->pict_type == AV_PICTURE_TYPE_I)

713 pkt->flags |= AV_PKT_FLAG_KEY;

714 *got_packet = 1;

715

716 return 0;

717 }

718

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

720 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

721 static const AVOption options[] = {

722 { "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"},

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

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

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

726

727 { NULL },

728 };

729

730 static const AVClass svq1enc_class = {

731 .class_name = "svq1enc",

732 .item_name = av_default_item_name,

733 .option = options,

734 .version = LIBAVUTIL_VERSION_INT,

735 };

736

737 const FFCodec ff_svq1_encoder = {

738 .p.name = "svq1",

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

740 .p.type = AVMEDIA_TYPE_VIDEO,

741 .p.id = AV_CODEC_ID_SVQ1,

742 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

743 .priv_data_size = sizeof(SVQ1EncContext),

744 .p.priv_class = &svq1enc_class,

745 .init = svq1_encode_init,

746 FF_CODEC_ENCODE_CB(svq1_encode_frame),

747 .close = svq1_encode_end,

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

749 AV_PIX_FMT_NONE },

750 .color_ranges = AVCOL_RANGE_MPEG,

751 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

752 };

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:33

ff_mpv_common_init

av_cold int ff_mpv_common_init(MpegEncContext *s)

init common structure for both encoder and decoder.

Definition: mpegvideo.c:687

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

level

uint8_t level

Definition: svq3.c:205

av_clip

#define av_clip

Definition: common.h:100

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

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

mem_internal.h

svq1enc_cb.h

ff_me_init

av_cold int ff_me_init(MotionEstContext *c, AVCodecContext *avctx, const MECmpContext *mecc, int mpvenc)

Definition: motion_est.c:308

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

ff_fix_long_p_mvs

void ff_fix_long_p_mvs(MpegEncContext *s, int type)

Definition: motion_est.c:1667

FF_ME_EPZS

#define FF_ME_EPZS

Definition: motion_est.h:42

write_ident

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

Definition: svq1enc.c:564

options

static const AVOption options[]

Definition: svq1enc.c:721

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

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

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

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

CANDIDATE_MB_TYPE_INTER

#define CANDIDATE_MB_TYPE_INTER

Definition: mpegvideoenc.h:41

AVFrame

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

Definition: frame.h:389

put_bits

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

put n times val bit

Definition: j2kenc.c:223

uint8_t w

Definition: llviddspenc.c:38

SVQ1EncContext::frame_width

int frame_width

Definition: svq1enc.c:77

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:539

#define VE

Definition: svq1enc.c:720

AVOption

AVOption.

Definition: opt.h:429

encode.h

FFCodec

Definition: codec_internal.h:127

version.h

SVQ1EncContext::pict_type

enum AVPictureType pict_type

Definition: svq1enc.c:70

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

FF_LAMBDA_SHIFT

#define FF_LAMBDA_SHIFT

Definition: avutil.h:225

mpegutils.h

SVQ1EncContext::encoded_block_levels

int16_t encoded_block_levels[6][7][256]

Definition: svq1enc.c:88

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:594

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

SVQ1EncContext::c_block_width

int c_block_width

Definition: svq1enc.c:85

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_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

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx

Definition: dsp.h:53

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

ff_h263_pred_motion

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

Definition: h263.c:179

SVQ1EncContext::svq1encdsp

SVQ1EncDSPContext svq1encdsp

Definition: svq1enc.c:101

ff_me_cmp_init

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

Definition: me_cmp.c:996

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:508

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:320

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

ff_mpv_common_end

void ff_mpv_common_end(MpegEncContext *s)

Definition: mpegvideo.c:774

avassert.h

pkt

AVPacket * pkt

Definition: movenc.c:60

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

SVQ1EncContext::last_picture

AVFrame * last_picture

Definition: svq1enc.c:67

emms_c

#define emms_c()

Definition: emms.h:63

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

SVQ1EncContext::y_block_height

int y_block_height

Definition: svq1enc.c:82

MAX_MB_BYTES

#define MAX_MB_BYTES

Definition: mpegutils.h:35

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

SVQ1_BLOCK_INTRA_LEN

#define SVQ1_BLOCK_INTRA_LEN

Definition: svq1.h:52

THRESHOLD_MULTIPLIER

#define THRESHOLD_MULTIPLIER

Definition: svq1enc.c:139

ff_svq1_encoder

const FFCodec ff_svq1_encoder

Definition: svq1enc.c:737

svq1_write_header

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

Definition: svq1enc.c:104

SVQ1EncContext::m

MpegEncContext m

Definition: svq1enc.c:62

PutBitContext

Definition: put_bits.h:50

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

ff_hpeldsp_init

av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)

Definition: hpeldsp.c:338

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my

Definition: dsp.h:53

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

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

ME_MAP_SIZE

#define ME_MAP_SIZE

Definition: motion_est.h:39

FF_ME_XONE

#define FF_ME_XONE

Definition: motion_est.h:43

AV_WB32

#define AV_WB32(p, v)

Definition: intreadwrite.h:415

svq1_encode_end

static av_cold int svq1_encode_end(AVCodecContext *avctx)

Definition: svq1enc.c:533

SVQ1EncContext::rd_total

int64_t rd_total

Definition: svq1enc.c:95

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

SVQ1EncContext::dummy

uint32_t * dummy

Definition: svq1enc.c:91

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

AVPacket::size

int size

Definition: packet.h:540

AVCodecContext::gop_size

int gop_size

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

Definition: avcodec.h:1037

height

#define height

Definition: dsp.h:85

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

OFFSET

#define OFFSET(x)

Definition: svq1enc.c:719

init_block_index

static void init_block_index(MpegEncContext *s)

Definition: svq1enc.c:294

size

int size

Definition: twinvq_data.h:10344

SVQ1EncContext::reorder_pb

PutBitContext reorder_pb[6]

Definition: svq1enc.c:75

CANDIDATE_MB_TYPE_INTRA

#define CANDIDATE_MB_TYPE_INTRA

Definition: mpegvideoenc.h:40

SVQ1EncContext::mb_type

uint16_t * mb_type

Definition: svq1enc.c:90

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

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_me_init_pic

void ff_me_init_pic(MpegEncContext *s)

Definition: motion_est.c:370

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

SVQ1EncContext::avctx

AVCodecContext * avctx

Definition: svq1enc.c:63

AV_CODEC_ID_SVQ1

@ AV_CODEC_ID_SVQ1

Definition: codec_id.h:74

emms.h

QUALITY_THRESHOLD

#define QUALITY_THRESHOLD

Definition: svq1enc.c:138

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

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

SVQ1EncContext::mecc

MECmpContext mecc

Definition: svq1enc.c:64

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

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

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

AVCodecContext::height

int height

Definition: avcodec.h:624

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:663

SVQ1EncContext::hdsp

HpelDSPContext hdsp

Definition: svq1enc.c:65

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:669

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

SVQ1EncContext::y_block_width

int y_block_width

Definition: svq1enc.c:81

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

me_cmp.h

SVQ1EncContext::motion_val16

int16_t(*[3] motion_val16)[2]

Definition: svq1enc.c:93

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

AVCodecContext

main external API structure.

Definition: avcodec.h:451

ff_estimate_p_frame_motion

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

Definition: motion_est.c:901

FF_MPV_OPT_FLAGS

#define FF_MPV_OPT_FLAGS

Definition: mpegvideoenc.h:83

ff_svq1_intra_mean_vlc

const uint16_t ff_svq1_intra_mean_vlc[256][2]

Definition: svq1_vlc.h:67

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

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

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

svq1enc_class

static const AVClass svq1enc_class

Definition: svq1enc.c:730

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:280

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

mem.h