FFmpeg
svq1enc.c
Go to the documentation of this file.
1 /*
2  * SVQ1 Encoder
3  * Copyright (C) 2004 Mike Melanson <melanson@pcisys.net>
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  */
21 
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  */
28 
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"
47 
48 #include "libavutil/avassert.h"
49 #include "libavutil/frame.h"
50 #include "libavutil/mem_internal.h"
51 
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
57 
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. */
68 
69  /* Some compression statistics */
71  int quality;
72 
73  /* why ooh why this sick breadth first order,
74  * everything is slower and more complex */
76 
79 
80  /* Y plane block dimensions */
83 
84  /* U & V plane (C planes) block dimensions */
87 
88  DECLARE_ALIGNED(16, int16_t, encoded_block_levels)[6][7][256];
89 
90  uint16_t *mb_type;
91  uint32_t *dummy;
92  int16_t (*motion_val8[3])[2];
93  int16_t (*motion_val16[3])[2];
94 
95  int64_t rd_total;
96 
97  uint8_t *scratchbuf;
98 
100 
103 
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 
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;
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;
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 
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.current_picture_ptr = &s->m.current_picture;
330  s->m.last_picture_ptr = &s->m.last_picture;
331  s->m.last_picture.f->data[0] = ref_plane;
332  s->m.linesize =
333  s->m.last_picture.f->linesize[0] =
334  s->m.new_picture->linesize[0] =
335  s->m.current_picture.f->linesize[0] = stride;
336  s->m.width = width;
337  s->m.height = height;
338  s->m.mb_width = block_width;
339  s->m.mb_height = block_height;
340  s->m.mb_stride = s->m.mb_width + 1;
341  s->m.b8_stride = 2 * s->m.mb_width + 1;
342  s->m.f_code = 1;
343  s->m.pict_type = s->pict_type;
344  s->m.motion_est = s->motion_est;
345  s->m.me.scene_change_score = 0;
346  // s->m.out_format = FMT_H263;
347  // s->m.unrestricted_mv = 1;
348  s->m.lambda = s->quality;
349  s->m.qscale = s->m.lambda * 139 +
350  FF_LAMBDA_SCALE * 64 >>
351  FF_LAMBDA_SHIFT + 7;
352  s->m.lambda2 = s->m.lambda * s->m.lambda +
353  FF_LAMBDA_SCALE / 2 >>
355 
356  if (!s->motion_val8[plane]) {
357  s->motion_val8[plane] = av_mallocz((s->m.b8_stride *
358  block_height * 2 + 2) *
359  2 * sizeof(int16_t));
360  s->motion_val16[plane] = av_mallocz((s->m.mb_stride *
361  (block_height + 2) + 1) *
362  2 * sizeof(int16_t));
363  if (!s->motion_val8[plane] || !s->motion_val16[plane])
364  return AVERROR(ENOMEM);
365  }
366 
367  s->m.mb_type = s->mb_type;
368 
369  // dummies, to avoid segfaults
370  s->m.mb_mean = (uint8_t *)s->dummy;
371  s->m.mb_var = (uint16_t *)s->dummy;
372  s->m.mc_mb_var = (uint16_t *)s->dummy;
373  s->m.current_picture.mb_type = s->dummy;
374 
375  s->m.current_picture.motion_val[0] = s->motion_val8[plane] + 2;
376  s->m.p_mv_table = s->motion_val16[plane] +
377  s->m.mb_stride + 1;
378  s->m.mecc = s->mecc; // move
379  ff_init_me(&s->m);
380 
381  s->m.me.dia_size = s->avctx->dia_size;
382  s->m.first_slice_line = 1;
383  for (y = 0; y < block_height; y++) {
384  s->m.new_picture->data[0] = src - y * 16 * stride; // ugly
385  s->m.mb_y = y;
386 
387  for (i = 0; i < 16 && i + 16 * y < height; i++) {
388  memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
389  width);
390  for (x = width; x < 16 * block_width; x++)
391  src[i * stride + x] = src[i * stride + x - 1];
392  }
393  for (; i < 16 && i + 16 * y < 16 * block_height; i++)
394  memcpy(&src[i * stride], &src[(i - 1) * stride],
395  16 * block_width);
396 
397  for (x = 0; x < block_width; x++) {
398  s->m.mb_x = x;
399  init_block_index(&s->m);
400 
401  ff_estimate_p_frame_motion(&s->m, x, y);
402  }
403  s->m.first_slice_line = 0;
404  }
405 
407  ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,
409  }
410 
411  s->m.first_slice_line = 1;
412  for (y = 0; y < block_height; y++) {
413  for (i = 0; i < 16 && i + 16 * y < height; i++) {
414  memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
415  width);
416  for (x = width; x < 16 * block_width; x++)
417  src[i * stride + x] = src[i * stride + x - 1];
418  }
419  for (; i < 16 && i + 16 * y < 16 * block_height; i++)
420  memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);
421 
422  s->m.mb_y = y;
423  for (x = 0; x < block_width; x++) {
424  uint8_t reorder_buffer[2][6][7 * 32];
425  int count[2][6];
426  int offset = y * 16 * stride + x * 16;
427  uint8_t *decoded = decoded_plane + offset;
428  const uint8_t *ref = ref_plane + offset;
429  int score[4] = { 0, 0, 0, 0 }, best;
430  uint8_t *temp = s->scratchbuf;
431 
432  if (put_bytes_left(pb, 0) < 3000) { // FIXME: check size
433  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
434  return -1;
435  }
436 
437  s->m.mb_x = x;
438  init_block_index(&s->m);
439 
440  if (s->pict_type == AV_PICTURE_TYPE_I ||
441  (s->m.mb_type[x + y * s->m.mb_stride] &
443  for (i = 0; i < 6; i++)
444  init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
445  7 * 32);
446  if (s->pict_type == AV_PICTURE_TYPE_P) {
448  score[0] = SVQ1_BLOCK_INTRA_LEN * lambda;
449  }
450  score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,
451  5, 64, lambda, 1);
452  for (i = 0; i < 6; i++) {
453  count[0][i] = put_bits_count(&s->reorder_pb[i]);
454  flush_put_bits(&s->reorder_pb[i]);
455  }
456  } else
457  score[0] = INT_MAX;
458 
459  best = 0;
460 
461  if (s->pict_type == AV_PICTURE_TYPE_P) {
462  int mx, my, pred_x, pred_y, dxy;
463  int16_t *motion_ptr;
464 
465  motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
466  if (s->m.mb_type[x + y * s->m.mb_stride] &
468  for (i = 0; i < 6; i++)
469  init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],
470  7 * 32);
471 
473 
474  s->m.pb = s->reorder_pb[5];
475  mx = motion_ptr[0];
476  my = motion_ptr[1];
477  av_assert1(mx >= -32 && mx <= 31);
478  av_assert1(my >= -32 && my <= 31);
479  av_assert1(pred_x >= -32 && pred_x <= 31);
480  av_assert1(pred_y >= -32 && pred_y <= 31);
481  ff_h263_encode_motion(&s->m.pb, mx - pred_x, 1);
482  ff_h263_encode_motion(&s->m.pb, my - pred_y, 1);
483  s->reorder_pb[5] = s->m.pb;
484  score[1] += lambda * put_bits_count(&s->reorder_pb[5]);
485 
486  dxy = (mx & 1) + 2 * (my & 1);
487 
488  s->hdsp.put_pixels_tab[0][dxy](temp + 16*stride,
489  ref + (mx >> 1) +
490  stride * (my >> 1),
491  stride, 16);
492 
493  score[1] += encode_block(s, src + 16 * x, temp + 16*stride,
494  decoded, stride, 5, 64, lambda, 0);
495  best = score[1] <= score[0];
496 
497  score[2] = s->mecc.sse[0](NULL, src + 16 * x, ref,
498  stride, 16);
499  score[2] += SVQ1_BLOCK_SKIP_LEN * lambda;
500  if (score[2] < score[best] && mx == 0 && my == 0) {
501  best = 2;
502  s->hdsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
504  }
505  }
506 
507  if (best == 1) {
508  for (i = 0; i < 6; i++) {
509  count[1][i] = put_bits_count(&s->reorder_pb[i]);
510  flush_put_bits(&s->reorder_pb[i]);
511  }
512  } else {
513  motion_ptr[0] =
514  motion_ptr[1] =
515  motion_ptr[2] =
516  motion_ptr[3] =
517  motion_ptr[0 + 2 * s->m.b8_stride] =
518  motion_ptr[1 + 2 * s->m.b8_stride] =
519  motion_ptr[2 + 2 * s->m.b8_stride] =
520  motion_ptr[3 + 2 * s->m.b8_stride] = 0;
521  }
522  }
523 
524  s->rd_total += score[best];
525 
526  if (best != 2)
527  for (i = 5; i >= 0; i--)
528  ff_copy_bits(pb, reorder_buffer[best][i],
529  count[best][i]);
530  if (best == 0)
531  s->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
532  }
533  s->m.first_slice_line = 0;
534  }
535  return 0;
536 }
537 
539 {
540  SVQ1EncContext *const s = avctx->priv_data;
541  int i;
542 
543  if (avctx->frame_num)
544  av_log(avctx, AV_LOG_DEBUG, "RD: %f\n",
545  s->rd_total / (double)(avctx->width * avctx->height *
546  avctx->frame_num));
547 
548  s->m.mb_type = NULL;
549  ff_mpv_common_end(&s->m);
550 
551  av_freep(&s->m.me.scratchpad);
552  av_freep(&s->m.me.map);
553  av_freep(&s->mb_type);
554  av_freep(&s->dummy);
555  av_freep(&s->scratchbuf);
556 
557  for (i = 0; i < 3; i++) {
558  av_freep(&s->motion_val8[i]);
559  av_freep(&s->motion_val16[i]);
560  }
561 
562  av_frame_free(&s->current_picture);
563  av_frame_free(&s->last_picture);
564  av_frame_free(&s->m.new_picture);
565 
566  return 0;
567 }
568 
569 static av_cold int write_ident(AVCodecContext *avctx, const char *ident)
570 {
571  int size = strlen(ident);
572  avctx->extradata = av_malloc(size + 8);
573  if (!avctx->extradata)
574  return AVERROR(ENOMEM);
575  AV_WB32(avctx->extradata, size + 8);
576  AV_WL32(avctx->extradata + 4, MKTAG('S', 'V', 'Q', '1'));
577  memcpy(avctx->extradata + 8, ident, size);
578  avctx->extradata_size = size + 8;
579  return 0;
580 }
581 
583 {
584  SVQ1EncContext *const s = avctx->priv_data;
585  int ret;
586 
587  if (avctx->width >= 4096 || avctx->height >= 4096) {
588  av_log(avctx, AV_LOG_ERROR, "Dimensions too large, maximum is 4095x4095\n");
589  return AVERROR(EINVAL);
590  }
591 
592  ff_hpeldsp_init(&s->hdsp, avctx->flags);
593  ff_me_cmp_init(&s->mecc, avctx);
594  ff_mpegvideoencdsp_init(&s->m.mpvencdsp, avctx);
595 
596  s->current_picture = av_frame_alloc();
597  s->last_picture = av_frame_alloc();
598  if (!s->current_picture || !s->last_picture) {
599  return AVERROR(ENOMEM);
600  }
601 
602  s->frame_width = avctx->width;
603  s->frame_height = avctx->height;
604 
605  s->y_block_width = (s->frame_width + 15) / 16;
606  s->y_block_height = (s->frame_height + 15) / 16;
607 
608  s->c_block_width = (s->frame_width / 4 + 15) / 16;
609  s->c_block_height = (s->frame_height / 4 + 15) / 16;
610 
611  s->avctx = avctx;
612  s->m.avctx = avctx;
613 
614  if ((ret = ff_mpv_common_init(&s->m)) < 0) {
615  return ret;
616  }
617 
618  s->m.picture_structure = PICT_FRAME;
619  s->m.me.temp =
620  s->m.me.scratchpad = av_mallocz((avctx->width + 64) *
621  2 * 16 * 2 * sizeof(uint8_t));
622  s->mb_type = av_mallocz((s->y_block_width + 1) *
623  s->y_block_height * sizeof(int16_t));
624  s->dummy = av_mallocz((s->y_block_width + 1) *
625  s->y_block_height * sizeof(int32_t));
626  s->m.me.map = av_mallocz(2 * ME_MAP_SIZE * sizeof(*s->m.me.map));
627  s->m.new_picture = av_frame_alloc();
628 
629  if (!s->m.me.scratchpad || !s->m.me.map ||
630  !s->mb_type || !s->dummy || !s->m.new_picture)
631  return AVERROR(ENOMEM);
632  s->m.me.score_map = s->m.me.map + ME_MAP_SIZE;
633 
634  ff_svq1enc_init(&s->svq1encdsp);
635 
636  ff_h263_encode_init(&s->m); // mv_penalty
637 
638  return write_ident(avctx, s->avctx->flags & AV_CODEC_FLAG_BITEXACT ? "Lavc" : LIBAVCODEC_IDENT);
639 }
640 
642  const AVFrame *pict, int *got_packet)
643 {
644  SVQ1EncContext *const s = avctx->priv_data;
645  PutBitContext pb;
646  int i, ret;
647 
648  ret = ff_alloc_packet(avctx, pkt, s->y_block_width * s->y_block_height *
650  if (ret < 0)
651  return ret;
652 
653  if (avctx->pix_fmt != AV_PIX_FMT_YUV410P) {
654  av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
655  return -1;
656  }
657 
658  if (!s->current_picture->data[0]) {
659  if ((ret = ff_encode_alloc_frame(avctx, s->current_picture)) < 0) {
660  return ret;
661  }
662  }
663  if (!s->last_picture->data[0]) {
664  ret = ff_encode_alloc_frame(avctx, s->last_picture);
665  if (ret < 0)
666  return ret;
667  }
668  if (!s->scratchbuf) {
669  s->scratchbuf = av_malloc_array(s->current_picture->linesize[0], 16 * 3);
670  if (!s->scratchbuf)
671  return AVERROR(ENOMEM);
672  }
673 
674  FFSWAP(AVFrame*, s->current_picture, s->last_picture);
675 
676  if (avctx->gop_size && (avctx->frame_num % avctx->gop_size))
677  s->pict_type = AV_PICTURE_TYPE_P;
678  else
679  s->pict_type = AV_PICTURE_TYPE_I;
680  s->quality = pict->quality;
681 
682  ff_side_data_set_encoder_stats(pkt, pict->quality, NULL, 0, s->pict_type);
683 
684  init_put_bits(&pb, pkt->data, pkt->size);
685  svq1_write_header(s, &pb, s->pict_type);
686  for (i = 0; i < 3; i++) {
687  int ret = svq1_encode_plane(s, i, &pb,
688  pict->data[i],
689  s->last_picture->data[i],
690  s->current_picture->data[i],
691  s->frame_width / (i ? 4 : 1),
692  s->frame_height / (i ? 4 : 1),
693  pict->linesize[i],
694  s->current_picture->linesize[i]);
695  emms_c();
696  if (ret < 0) {
697  int j;
698  for (j = 0; j < i; j++) {
699  av_freep(&s->motion_val8[j]);
700  av_freep(&s->motion_val16[j]);
701  }
702  av_freep(&s->scratchbuf);
703  return -1;
704  }
705  }
706 
707  // align_put_bits(&pb);
708  while (put_bits_count(&pb) & 31)
709  put_bits(&pb, 1, 0);
710 
711  flush_put_bits(&pb);
712 
713  pkt->size = put_bytes_output(&pb);
714  if (s->pict_type == AV_PICTURE_TYPE_I)
716  *got_packet = 1;
717 
718  return 0;
719 }
720 
721 #define OFFSET(x) offsetof(struct SVQ1EncContext, x)
722 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
723 static const AVOption options[] = {
724  { "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"},
725  { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" },
726  { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" },
727  { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" },
728 
729  { NULL },
730 };
731 
732 static const AVClass svq1enc_class = {
733  .class_name = "svq1enc",
734  .item_name = av_default_item_name,
735  .option = options,
736  .version = LIBAVUTIL_VERSION_INT,
737 };
738 
740  .p.name = "svq1",
741  CODEC_LONG_NAME("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
742  .p.type = AVMEDIA_TYPE_VIDEO,
743  .p.id = AV_CODEC_ID_SVQ1,
745  .priv_data_size = sizeof(SVQ1EncContext),
746  .p.priv_class = &svq1enc_class,
747  .init = svq1_encode_init,
749  .close = svq1_encode_end,
750  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
751  AV_PIX_FMT_NONE },
752  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
753 };
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:682
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:205
av_clip
#define av_clip
Definition: common.h:99
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:99
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:569
options
static const AVOption options[]
Definition: svq1enc.c:723
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
AVPictureType
Definition: avutil.h:277
SVQ1EncContext
Definition: svq1enc.c:58
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:641
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:160
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:374
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
w
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:524
VE
#define VE
Definition: svq1enc.c:722
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: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:579
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:395
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_mpegvideoencdsp_init
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
Definition: mpegvideoencdsp.c:232
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
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:831
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:101
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:148
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:783
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:524
SVQ1EncContext::y_block_height
int y_block_height
Definition: svq1enc.c:82
width
#define width
MAX_MB_BYTES
#define MAX_MB_BYTES
Definition: mpegutils.h:35
SVQ1_BLOCK_SKIP_LEN
#define SVQ1_BLOCK_SKIP_LEN
Definition: svq1.h:48
s
#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:739
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: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: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: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:538
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:818
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:525
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:506
OFFSET
#define OFFSET(x)
Definition: svq1enc.c:721
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:165
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
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:530
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
i
#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
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: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: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: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
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:65
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:81
SVQ1EncDSPContext
Definition: svq1encdsp.h:28
ret
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: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: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
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:863
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:732
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
packet_internal.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
SVQ1EncContext::scratchbuf
uint8_t * scratchbuf
Definition: svq1enc.c:97
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
int32_t
int32_t
Definition: audioconvert.c:56
hpeldsp.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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: packet.c:607
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2038
ff_h263_encode_motion
void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
Definition: ituh263enc.c:692
int
int
Definition: ffmpeg_filter.c:424
put_bits.h
ff_svq1_frame_size_table
const uint16_t ff_svq1_frame_size_table[7][2]
Definition: svq1.c:40
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
svq1_encode_init
static av_cold int svq1_encode_init(AVCodecContext *avctx)
Definition: svq1enc.c:582
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:41
FF_ME_ZERO
#define FF_ME_ZERO
Definition: motion_est.h:40
h263.h