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 
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.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 >>
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 
404  ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,
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] &
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) {
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] &
465  for (i = 0; i < 6; i++)
466  init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],
467  7 * 32);
468 
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);
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 
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 
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 
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 *
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)
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 
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,
743  .priv_data_size = sizeof(SVQ1EncContext),
744  .p.priv_class = &svq1enc_class,
745  .init = svq1_encode_init,
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
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
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
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:539
VE
#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
mx
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:209
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
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:230
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
my
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:75
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:166
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
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: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:700
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
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:80
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
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:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
ff_mpegvideoencdsp_init
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
Definition: mpegvideoencdsp.c:253
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
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:434
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:609
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2070
width
#define width
Definition: dsp.h:85
ff_h263_encode_motion
void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
Definition: ituh263enc.c:707
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
Special option type for declaring named constants.
Definition: opt.h:299
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
svq1_encode_init
static av_cold int svq1_encode_init(AVCodecContext *avctx)
Definition: svq1enc.c:577
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
src
#define src
Definition: vp8dsp.c:248
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:41
FF_ME_ZERO
#define FF_ME_ZERO
Definition: motion_est.h:41
h263.h