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 "avcodec.h"
31 #include "codec_internal.h"
32 #include "encode.h"
33 #include "hpeldsp.h"
34 #include "me_cmp.h"
35 #include "mpegvideo.h"
36 #include "h263.h"
37 #include "h263enc.h"
38 #include "internal.h"
39 #include "mpegutils.h"
40 #include "packet_internal.h"
41 #include "put_bits.h"
42 #include "svq1.h"
43 #include "svq1encdsp.h"
44 #include "svq1enc_cb.h"
45 #include "version.h"
46 
47 #include "libavutil/avassert.h"
48 #include "libavutil/frame.h"
49 #include "libavutil/mem_internal.h"
50 
51 // Workaround for GCC bug 102513
52 #if AV_GCC_VERSION_AT_LEAST(10, 0) && AV_GCC_VERSION_AT_MOST(12, 0) \
53  && !defined(__clang__) && !defined(__INTEL_COMPILER)
54 #pragma GCC optimize ("no-ipa-cp-clone")
55 #endif
56 
57 typedef struct SVQ1EncContext {
58  /* FIXME: Needed for motion estimation, should not be used for anything
59  * else, the idea is to make the motion estimation eventually independent
60  * of MpegEncContext, so this will be removed then. */
67 
68  /* Some compression statistics */
70  int quality;
71 
72  /* why ooh why this sick breadth first order,
73  * everything is slower and more complex */
75 
78 
79  /* Y plane block dimensions */
82 
83  /* U & V plane (C planes) block dimensions */
86 
87  DECLARE_ALIGNED(16, int16_t, encoded_block_levels)[6][7][256];
88 
89  uint16_t *mb_type;
90  uint32_t *dummy;
91  int16_t (*motion_val8[3])[2];
92  int16_t (*motion_val16[3])[2];
93 
94  int64_t rd_total;
95 
96  uint8_t *scratchbuf;
97 
99 
102 
104 {
105  int i;
106 
107  /* frame code */
108  put_bits(pb, 22, 0x20);
109 
110  /* temporal reference (sure hope this is a "don't care") */
111  put_bits(pb, 8, 0x00);
112 
113  /* frame type */
114  put_bits(pb, 2, frame_type - 1);
115 
116  if (frame_type == AV_PICTURE_TYPE_I) {
117  /* no checksum since frame code is 0x20 */
118  /* no embedded string either */
119  /* output 5 unknown bits (2 + 2 + 1) */
120  put_bits(pb, 5, 2); /* 2 needed by quicktime decoder */
121 
124  s->frame_width, s->frame_height);
125  put_bits(pb, 3, i);
126 
127  if (i == 7) {
128  put_bits(pb, 12, s->frame_width);
129  put_bits(pb, 12, s->frame_height);
130  }
131  }
132 
133  /* no checksum or extra data (next 2 bits get 0) */
134  put_bits(pb, 2, 0);
135 }
136 
137 #define QUALITY_THRESHOLD 100
138 #define THRESHOLD_MULTIPLIER 0.6
139 
140 static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
141  intptr_t size)
142 {
143  int score = 0, i;
144 
145  for (i = 0; i < size; i++)
146  score += (pix1[i] - pix2[i]) * (pix1[i] - pix2[i]);
147  return score;
148 }
149 
150 static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref,
151  uint8_t *decoded, int stride, unsigned level,
152  int threshold, int lambda, int intra)
153 {
154  int count, y, x, i, j, split, best_mean, best_score, best_count;
155  int best_vector[6];
156  int block_sum[7] = { 0, 0, 0, 0, 0, 0 };
157  int w = 2 << (level + 2 >> 1);
158  int h = 2 << (level + 1 >> 1);
159  int size = w * h;
160  int16_t (*block)[256] = s->encoded_block_levels[level];
161  const int8_t *codebook_sum, *codebook;
162  const uint16_t(*mean_vlc)[2];
163  const uint8_t(*multistage_vlc)[2];
164 
165  best_score = 0;
166  // FIXME: Optimize, this does not need to be done multiple times.
167  if (intra) {
168  // level is 5 when encode_block is called from svq1_encode_plane
169  // and always < 4 when called recursively from this function.
170  codebook_sum = level < 4 ? svq1_intra_codebook_sum[level] : NULL;
172  mean_vlc = ff_svq1_intra_mean_vlc;
173  multistage_vlc = ff_svq1_intra_multistage_vlc[level];
174  for (y = 0; y < h; y++) {
175  for (x = 0; x < w; x++) {
176  int v = src[x + y * stride];
177  block[0][x + w * y] = v;
178  best_score += v * v;
179  block_sum[0] += v;
180  }
181  }
182  } else {
183  // level is 5 or < 4, see above for details.
184  codebook_sum = level < 4 ? svq1_inter_codebook_sum[level] : NULL;
186  mean_vlc = ff_svq1_inter_mean_vlc + 256;
187  multistage_vlc = ff_svq1_inter_multistage_vlc[level];
188  for (y = 0; y < h; y++) {
189  for (x = 0; x < w; x++) {
190  int v = src[x + y * stride] - ref[x + y * stride];
191  block[0][x + w * y] = v;
192  best_score += v * v;
193  block_sum[0] += v;
194  }
195  }
196  }
197 
198  best_count = 0;
199  best_score -= (int)((unsigned)block_sum[0] * block_sum[0] >> (level + 3));
200  best_mean = block_sum[0] + (size >> 1) >> (level + 3);
201 
202  if (level < 4) {
203  for (count = 1; count < 7; count++) {
204  int best_vector_score = INT_MAX;
205  int best_vector_sum = -999, best_vector_mean = -999;
206  const int stage = count - 1;
207  const int8_t *vector;
208 
209  for (i = 0; i < 16; i++) {
210  int sum = codebook_sum[stage * 16 + i];
211  int sqr, diff, score;
212 
213  vector = codebook + stage * size * 16 + i * size;
214  sqr = s->svq1encdsp.ssd_int8_vs_int16(vector, block[stage], size);
215  diff = block_sum[stage] - sum;
216  score = sqr - (diff * (int64_t)diff >> (level + 3)); // FIXME: 64 bits slooow
217  if (score < best_vector_score) {
218  int mean = diff + (size >> 1) >> (level + 3);
219  av_assert2(mean > -300 && mean < 300);
220  mean = av_clip(mean, intra ? 0 : -256, 255);
221  best_vector_score = score;
222  best_vector[stage] = i;
223  best_vector_sum = sum;
224  best_vector_mean = mean;
225  }
226  }
227  av_assert0(best_vector_mean != -999);
228  vector = codebook + stage * size * 16 + best_vector[stage] * size;
229  for (j = 0; j < size; j++)
230  block[stage + 1][j] = block[stage][j] - vector[j];
231  block_sum[stage + 1] = block_sum[stage] - best_vector_sum;
232  best_vector_score += lambda *
233  (+1 + 4 * count +
234  multistage_vlc[1 + count][1]
235  + mean_vlc[best_vector_mean][1]);
236 
237  if (best_vector_score < best_score) {
238  best_score = best_vector_score;
239  best_count = count;
240  best_mean = best_vector_mean;
241  }
242  }
243  }
244 
245  if (best_mean == -128)
246  best_mean = -127;
247  else if (best_mean == 128)
248  best_mean = 127;
249 
250  split = 0;
251  if (best_score > threshold && level) {
252  int score = 0;
253  int offset = level & 1 ? stride * h / 2 : w / 2;
254  PutBitContext backup[6];
255 
256  for (i = level - 1; i >= 0; i--)
257  backup[i] = s->reorder_pb[i];
258  score += encode_block(s, src, ref, decoded, stride, level - 1,
259  threshold >> 1, lambda, intra);
260  score += encode_block(s, src + offset, ref + offset, decoded + offset,
261  stride, level - 1, threshold >> 1, lambda, intra);
262  score += lambda;
263 
264  if (score < best_score) {
265  best_score = score;
266  split = 1;
267  } else {
268  for (i = level - 1; i >= 0; i--)
269  s->reorder_pb[i] = backup[i];
270  }
271  }
272  if (level > 0)
273  put_bits(&s->reorder_pb[level], 1, split);
274 
275  if (!split) {
276  av_assert1(best_mean >= 0 && best_mean < 256 || !intra);
277  av_assert1(best_mean >= -256 && best_mean < 256);
278  av_assert1(best_count >= 0 && best_count < 7);
279  av_assert1(level < 4 || best_count == 0);
280 
281  /* output the encoding */
282  put_bits(&s->reorder_pb[level],
283  multistage_vlc[1 + best_count][1],
284  multistage_vlc[1 + best_count][0]);
285  put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
286  mean_vlc[best_mean][0]);
287 
288  for (i = 0; i < best_count; i++) {
289  av_assert2(best_vector[i] >= 0 && best_vector[i] < 16);
290  put_bits(&s->reorder_pb[level], 4, best_vector[i]);
291  }
292 
293  for (y = 0; y < h; y++)
294  for (x = 0; x < w; x++)
295  decoded[x + y * stride] = src[x + y * stride] -
296  block[best_count][x + w * y] +
297  best_mean;
298  }
299 
300  return best_score;
301 }
302 
304  s->block_index[0]= s->b8_stride*(s->mb_y*2 ) + s->mb_x*2;
305  s->block_index[1]= s->b8_stride*(s->mb_y*2 ) + 1 + s->mb_x*2;
306  s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) + s->mb_x*2;
307  s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) + 1 + s->mb_x*2;
308  s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x;
309  s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x;
310 }
311 
312 static int svq1_encode_plane(SVQ1EncContext *s, int plane,
313  PutBitContext *pb,
314  const unsigned char *src_plane,
315  unsigned char *ref_plane,
316  unsigned char *decoded_plane,
317  int width, int height, int src_stride, int stride)
318 {
319  int x, y;
320  int i;
321  int block_width, block_height;
322  int level;
323  int threshold[6];
324  uint8_t *src = s->scratchbuf + stride * 32;
325  const int lambda = (s->quality * s->quality) >>
326  (2 * FF_LAMBDA_SHIFT);
327 
328  /* figure out the acceptable level thresholds in advance */
329  threshold[5] = QUALITY_THRESHOLD;
330  for (level = 4; level >= 0; level--)
331  threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
332 
333  block_width = (width + 15) / 16;
334  block_height = (height + 15) / 16;
335 
336  if (s->pict_type == AV_PICTURE_TYPE_P) {
337  s->m.avctx = s->avctx;
338  s->m.current_picture_ptr = &s->m.current_picture;
339  s->m.last_picture_ptr = &s->m.last_picture;
340  s->m.last_picture.f->data[0] = ref_plane;
341  s->m.linesize =
342  s->m.last_picture.f->linesize[0] =
343  s->m.new_picture->linesize[0] =
344  s->m.current_picture.f->linesize[0] = stride;
345  s->m.width = width;
346  s->m.height = height;
347  s->m.mb_width = block_width;
348  s->m.mb_height = block_height;
349  s->m.mb_stride = s->m.mb_width + 1;
350  s->m.b8_stride = 2 * s->m.mb_width + 1;
351  s->m.f_code = 1;
352  s->m.pict_type = s->pict_type;
353  s->m.motion_est = s->motion_est;
354  s->m.me.scene_change_score = 0;
355  // s->m.out_format = FMT_H263;
356  // s->m.unrestricted_mv = 1;
357  s->m.lambda = s->quality;
358  s->m.qscale = s->m.lambda * 139 +
359  FF_LAMBDA_SCALE * 64 >>
360  FF_LAMBDA_SHIFT + 7;
361  s->m.lambda2 = s->m.lambda * s->m.lambda +
362  FF_LAMBDA_SCALE / 2 >>
364 
365  if (!s->motion_val8[plane]) {
366  s->motion_val8[plane] = av_mallocz((s->m.b8_stride *
367  block_height * 2 + 2) *
368  2 * sizeof(int16_t));
369  s->motion_val16[plane] = av_mallocz((s->m.mb_stride *
370  (block_height + 2) + 1) *
371  2 * sizeof(int16_t));
372  if (!s->motion_val8[plane] || !s->motion_val16[plane])
373  return AVERROR(ENOMEM);
374  }
375 
376  s->m.mb_type = s->mb_type;
377 
378  // dummies, to avoid segfaults
379  s->m.mb_mean = (uint8_t *)s->dummy;
380  s->m.mb_var = (uint16_t *)s->dummy;
381  s->m.mc_mb_var = (uint16_t *)s->dummy;
382  s->m.current_picture.mb_type = s->dummy;
383 
384  s->m.current_picture.motion_val[0] = s->motion_val8[plane] + 2;
385  s->m.p_mv_table = s->motion_val16[plane] +
386  s->m.mb_stride + 1;
387  s->m.mecc = s->mecc; // move
388  ff_init_me(&s->m);
389 
390  s->m.me.dia_size = s->avctx->dia_size;
391  s->m.first_slice_line = 1;
392  for (y = 0; y < block_height; y++) {
393  s->m.new_picture->data[0] = src - y * 16 * stride; // ugly
394  s->m.mb_y = y;
395 
396  for (i = 0; i < 16 && i + 16 * y < height; i++) {
397  memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
398  width);
399  for (x = width; x < 16 * block_width; x++)
400  src[i * stride + x] = src[i * stride + x - 1];
401  }
402  for (; i < 16 && i + 16 * y < 16 * block_height; i++)
403  memcpy(&src[i * stride], &src[(i - 1) * stride],
404  16 * block_width);
405 
406  for (x = 0; x < block_width; x++) {
407  s->m.mb_x = x;
408  init_block_index(&s->m);
409 
410  ff_estimate_p_frame_motion(&s->m, x, y);
411  }
412  s->m.first_slice_line = 0;
413  }
414 
416  ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,
418  }
419 
420  s->m.first_slice_line = 1;
421  for (y = 0; y < block_height; y++) {
422  for (i = 0; i < 16 && i + 16 * y < height; i++) {
423  memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
424  width);
425  for (x = width; x < 16 * block_width; x++)
426  src[i * stride + x] = src[i * stride + x - 1];
427  }
428  for (; i < 16 && i + 16 * y < 16 * block_height; i++)
429  memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);
430 
431  s->m.mb_y = y;
432  for (x = 0; x < block_width; x++) {
433  uint8_t reorder_buffer[2][6][7 * 32];
434  int count[2][6];
435  int offset = y * 16 * stride + x * 16;
436  uint8_t *decoded = decoded_plane + offset;
437  const uint8_t *ref = ref_plane + offset;
438  int score[4] = { 0, 0, 0, 0 }, best;
439  uint8_t *temp = s->scratchbuf;
440 
441  if (put_bytes_left(pb, 0) < 3000) { // FIXME: check size
442  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
443  return -1;
444  }
445 
446  s->m.mb_x = x;
447  init_block_index(&s->m);
448 
449  if (s->pict_type == AV_PICTURE_TYPE_I ||
450  (s->m.mb_type[x + y * s->m.mb_stride] &
452  for (i = 0; i < 6; i++)
453  init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
454  7 * 32);
455  if (s->pict_type == AV_PICTURE_TYPE_P) {
457  score[0] = SVQ1_BLOCK_INTRA_LEN * lambda;
458  }
459  score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,
460  5, 64, lambda, 1);
461  for (i = 0; i < 6; i++) {
462  count[0][i] = put_bits_count(&s->reorder_pb[i]);
463  flush_put_bits(&s->reorder_pb[i]);
464  }
465  } else
466  score[0] = INT_MAX;
467 
468  best = 0;
469 
470  if (s->pict_type == AV_PICTURE_TYPE_P) {
471  int mx, my, pred_x, pred_y, dxy;
472  int16_t *motion_ptr;
473 
474  motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
475  if (s->m.mb_type[x + y * s->m.mb_stride] &
477  for (i = 0; i < 6; i++)
478  init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],
479  7 * 32);
480 
482 
483  s->m.pb = s->reorder_pb[5];
484  mx = motion_ptr[0];
485  my = motion_ptr[1];
486  av_assert1(mx >= -32 && mx <= 31);
487  av_assert1(my >= -32 && my <= 31);
488  av_assert1(pred_x >= -32 && pred_x <= 31);
489  av_assert1(pred_y >= -32 && pred_y <= 31);
490  ff_h263_encode_motion(&s->m.pb, mx - pred_x, 1);
491  ff_h263_encode_motion(&s->m.pb, my - pred_y, 1);
492  s->reorder_pb[5] = s->m.pb;
493  score[1] += lambda * put_bits_count(&s->reorder_pb[5]);
494 
495  dxy = (mx & 1) + 2 * (my & 1);
496 
497  s->hdsp.put_pixels_tab[0][dxy](temp + 16*stride,
498  ref + (mx >> 1) +
499  stride * (my >> 1),
500  stride, 16);
501 
502  score[1] += encode_block(s, src + 16 * x, temp + 16*stride,
503  decoded, stride, 5, 64, lambda, 0);
504  best = score[1] <= score[0];
505 
506  score[2] = s->mecc.sse[0](NULL, src + 16 * x, ref,
507  stride, 16);
508  score[2] += SVQ1_BLOCK_SKIP_LEN * lambda;
509  if (score[2] < score[best] && mx == 0 && my == 0) {
510  best = 2;
511  s->hdsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
513  }
514  }
515 
516  if (best == 1) {
517  for (i = 0; i < 6; i++) {
518  count[1][i] = put_bits_count(&s->reorder_pb[i]);
519  flush_put_bits(&s->reorder_pb[i]);
520  }
521  } else {
522  motion_ptr[0] =
523  motion_ptr[1] =
524  motion_ptr[2] =
525  motion_ptr[3] =
526  motion_ptr[0 + 2 * s->m.b8_stride] =
527  motion_ptr[1 + 2 * s->m.b8_stride] =
528  motion_ptr[2 + 2 * s->m.b8_stride] =
529  motion_ptr[3 + 2 * s->m.b8_stride] = 0;
530  }
531  }
532 
533  s->rd_total += score[best];
534 
535  if (best != 2)
536  for (i = 5; i >= 0; i--)
537  ff_copy_bits(pb, reorder_buffer[best][i],
538  count[best][i]);
539  if (best == 0)
540  s->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
541  }
542  s->m.first_slice_line = 0;
543  }
544  return 0;
545 }
546 
548 {
549  SVQ1EncContext *const s = avctx->priv_data;
550  int i;
551 
552  if (avctx->frame_num)
553  av_log(avctx, AV_LOG_DEBUG, "RD: %f\n",
554  s->rd_total / (double)(avctx->width * avctx->height *
555  avctx->frame_num));
556 
557  s->m.mb_type = NULL;
558  ff_mpv_common_end(&s->m);
559 
560  av_freep(&s->m.me.scratchpad);
561  av_freep(&s->m.me.map);
562  av_freep(&s->mb_type);
563  av_freep(&s->dummy);
564  av_freep(&s->scratchbuf);
565 
566  for (i = 0; i < 3; i++) {
567  av_freep(&s->motion_val8[i]);
568  av_freep(&s->motion_val16[i]);
569  }
570 
571  av_frame_free(&s->current_picture);
572  av_frame_free(&s->last_picture);
573  av_frame_free(&s->m.new_picture);
574 
575  return 0;
576 }
577 
578 static av_cold int write_ident(AVCodecContext *avctx, const char *ident)
579 {
580  int size = strlen(ident);
581  avctx->extradata = av_malloc(size + 8);
582  if (!avctx->extradata)
583  return AVERROR(ENOMEM);
584  AV_WB32(avctx->extradata, size + 8);
585  AV_WL32(avctx->extradata + 4, MKTAG('S', 'V', 'Q', '1'));
586  memcpy(avctx->extradata + 8, ident, size);
587  avctx->extradata_size = size + 8;
588  return 0;
589 }
590 
592 {
593  SVQ1EncContext *const s = avctx->priv_data;
594  int ret;
595 
596  if (avctx->width >= 4096 || avctx->height >= 4096) {
597  av_log(avctx, AV_LOG_ERROR, "Dimensions too large, maximum is 4095x4095\n");
598  return AVERROR(EINVAL);
599  }
600 
601  ff_hpeldsp_init(&s->hdsp, avctx->flags);
602  ff_me_cmp_init(&s->mecc, avctx);
603  ff_mpegvideoencdsp_init(&s->m.mpvencdsp, avctx);
604 
605  s->current_picture = av_frame_alloc();
606  s->last_picture = av_frame_alloc();
607  if (!s->current_picture || !s->last_picture) {
608  return AVERROR(ENOMEM);
609  }
610 
611  s->frame_width = avctx->width;
612  s->frame_height = avctx->height;
613 
614  s->y_block_width = (s->frame_width + 15) / 16;
615  s->y_block_height = (s->frame_height + 15) / 16;
616 
617  s->c_block_width = (s->frame_width / 4 + 15) / 16;
618  s->c_block_height = (s->frame_height / 4 + 15) / 16;
619 
620  s->avctx = avctx;
621  s->m.avctx = avctx;
622 
623  if ((ret = ff_mpv_common_init(&s->m)) < 0) {
624  return ret;
625  }
626 
627  s->m.picture_structure = PICT_FRAME;
628  s->m.me.temp =
629  s->m.me.scratchpad = av_mallocz((avctx->width + 64) *
630  2 * 16 * 2 * sizeof(uint8_t));
631  s->mb_type = av_mallocz((s->y_block_width + 1) *
632  s->y_block_height * sizeof(int16_t));
633  s->dummy = av_mallocz((s->y_block_width + 1) *
634  s->y_block_height * sizeof(int32_t));
635  s->m.me.map = av_mallocz(2 * ME_MAP_SIZE * sizeof(*s->m.me.map));
636  s->m.new_picture = av_frame_alloc();
637  s->svq1encdsp.ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
638 
639  if (!s->m.me.scratchpad || !s->m.me.map ||
640  !s->mb_type || !s->dummy || !s->m.new_picture)
641  return AVERROR(ENOMEM);
642  s->m.me.score_map = s->m.me.map + ME_MAP_SIZE;
643 
644 #if ARCH_PPC
645  ff_svq1enc_init_ppc(&s->svq1encdsp);
646 #elif ARCH_X86
647  ff_svq1enc_init_x86(&s->svq1encdsp);
648 #endif
649 
650  ff_h263_encode_init(&s->m); // mv_penalty
651 
652  return write_ident(avctx, s->avctx->flags & AV_CODEC_FLAG_BITEXACT ? "Lavc" : LIBAVCODEC_IDENT);
653 }
654 
656  const AVFrame *pict, int *got_packet)
657 {
658  SVQ1EncContext *const s = avctx->priv_data;
659  PutBitContext pb;
660  int i, ret;
661 
662  ret = ff_alloc_packet(avctx, pkt, s->y_block_width * s->y_block_height *
664  if (ret < 0)
665  return ret;
666 
667  if (avctx->pix_fmt != AV_PIX_FMT_YUV410P) {
668  av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
669  return -1;
670  }
671 
672  if (!s->current_picture->data[0]) {
673  if ((ret = ff_encode_alloc_frame(avctx, s->current_picture)) < 0) {
674  return ret;
675  }
676  }
677  if (!s->last_picture->data[0]) {
678  ret = ff_encode_alloc_frame(avctx, s->last_picture);
679  if (ret < 0)
680  return ret;
681  }
682  if (!s->scratchbuf) {
683  s->scratchbuf = av_malloc_array(s->current_picture->linesize[0], 16 * 3);
684  if (!s->scratchbuf)
685  return AVERROR(ENOMEM);
686  }
687 
688  FFSWAP(AVFrame*, s->current_picture, s->last_picture);
689 
690  if (avctx->gop_size && (avctx->frame_num % avctx->gop_size))
691  s->pict_type = AV_PICTURE_TYPE_P;
692  else
693  s->pict_type = AV_PICTURE_TYPE_I;
694  s->quality = pict->quality;
695 
696  ff_side_data_set_encoder_stats(pkt, pict->quality, NULL, 0, s->pict_type);
697 
698  init_put_bits(&pb, pkt->data, pkt->size);
699  svq1_write_header(s, &pb, s->pict_type);
700  for (i = 0; i < 3; i++) {
701  int ret = svq1_encode_plane(s, i, &pb,
702  pict->data[i],
703  s->last_picture->data[i],
704  s->current_picture->data[i],
705  s->frame_width / (i ? 4 : 1),
706  s->frame_height / (i ? 4 : 1),
707  pict->linesize[i],
708  s->current_picture->linesize[i]);
709  emms_c();
710  if (ret < 0) {
711  int j;
712  for (j = 0; j < i; j++) {
713  av_freep(&s->motion_val8[j]);
714  av_freep(&s->motion_val16[j]);
715  }
716  av_freep(&s->scratchbuf);
717  return -1;
718  }
719  }
720 
721  // align_put_bits(&pb);
722  while (put_bits_count(&pb) & 31)
723  put_bits(&pb, 1, 0);
724 
725  flush_put_bits(&pb);
726 
727  pkt->size = put_bytes_output(&pb);
728  if (s->pict_type == AV_PICTURE_TYPE_I)
730  *got_packet = 1;
731 
732  return 0;
733 }
734 
735 #define OFFSET(x) offsetof(struct SVQ1EncContext, x)
736 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
737 static const AVOption options[] = {
738  { "motion-est", "Motion estimation algorithm", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, VE, "motion-est"},
739  { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
740  { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
741  { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
742 
743  { NULL },
744 };
745 
746 static const AVClass svq1enc_class = {
747  .class_name = "svq1enc",
748  .option = options,
749  .version = LIBAVUTIL_VERSION_INT,
750 };
751 
753  .p.name = "svq1",
754  CODEC_LONG_NAME("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
755  .p.type = AVMEDIA_TYPE_VIDEO,
756  .p.id = AV_CODEC_ID_SVQ1,
758  .priv_data_size = sizeof(SVQ1EncContext),
759  .p.priv_class = &svq1enc_class,
760  .init = svq1_encode_init,
762  .close = svq1_encode_end,
763  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
764  AV_PIX_FMT_NONE },
765  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
766 };
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:150
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:681
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:96
THRESHOLD_MULTIPLIER
#define THRESHOLD_MULTIPLIER
Definition: svq1enc.c:138
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
FF_LAMBDA_SCALE
#define FF_LAMBDA_SCALE
Definition: avutil.h:226
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:43
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
mem_internal.h
svq1enc_cb.h
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
SVQ1EncContext::motion_est
int motion_est
Definition: svq1enc.c:98
ff_fix_long_p_mvs
void ff_fix_long_p_mvs(MpegEncContext *s, int type)
Definition: motion_est.c:1655
FF_ME_EPZS
#define FF_ME_EPZS
Definition: motion_est.h:41
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:606
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:57
block_sum
static int block_sum(const uint8_t *block, int w, int h, int linesize)
Definition: mobiclip.c:812
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
ff_svq1_encoder
const FFCodec ff_svq1_encoder
Definition: svq1enc.c:752
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:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:222
w
uint8_t w
Definition: llviddspenc.c:38
SVQ1EncContext::frame_width
int frame_width
Definition: svq1enc.c:76
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:515
AVOption
AVOption.
Definition: opt.h:249
encode.h
FFCodec
Definition: codec_internal.h:127
version.h
SVQ1EncContext::pict_type
enum AVPictureType pict_type
Definition: svq1enc.c:69
SVQ1_BLOCK_SKIP_CODE
#define SVQ1_BLOCK_SKIP_CODE
Definition: svq1.h:47
mpegvideo.h
sqr
static double sqr(double in)
Definition: af_afwtdn.c:871
FF_LAMBDA_SHIFT
#define FF_LAMBDA_SHIFT
Definition: avutil.h:225
CANDIDATE_MB_TYPE_INTER
#define CANDIDATE_MB_TYPE_INTER
Definition: mpegutils.h:98
mpegutils.h
SVQ1EncContext::encoded_block_levels
int16_t encoded_block_levels[6][7][256]
Definition: svq1enc.c:87
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:570
svq1_inter_codebook_sum
static const int8_t svq1_inter_codebook_sum[4][16 *6]
Definition: svq1enc_cb.h:32
svq1encdsp.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
SVQ1EncContext::c_block_width
int c_block_width
Definition: svq1enc.c:84
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
ff_svq1_intra_multistage_vlc
const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]
Definition: svq1_vlc.h:33
ff_mpegvideoencdsp_init
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
Definition: mpegvideoencdsp.c:232
ff_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:852
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:190
SVQ1EncContext::svq1encdsp
SVQ1EncDSPContext svq1encdsp
Definition: svq1enc.c:100
ff_me_cmp_init
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:1008
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:521
init_block_index
static void init_block_index(MpegEncContext *s)
Definition: svq1enc.c:303
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:315
put_bytes_left
static int put_bytes_left(const PutBitContext *s, int round_up)
Definition: put_bits.h:135
ssd_int8_vs_int16_c
static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2, intptr_t size)
Definition: svq1enc.c:140
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
svq1_encode_init
static av_cold int svq1_encode_init(AVCodecContext *avctx)
Definition: svq1enc.c:591
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:782
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
SVQ1EncContext::last_picture
AVFrame * last_picture
Definition: svq1enc.c:66
emms_c
#define emms_c()
Definition: emms.h:63
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:543
SVQ1EncContext::y_block_height
int y_block_height
Definition: svq1enc.c:81
width
#define width
MAX_MB_BYTES
#define MAX_MB_BYTES
Definition: mpegutils.h:40
SVQ1_BLOCK_SKIP_LEN
#define SVQ1_BLOCK_SKIP_LEN
Definition: svq1.h:48
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
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:195
SVQ1EncContext::frame_height
int frame_height
Definition: svq1enc.c:77
SVQ1_BLOCK_INTRA_LEN
#define SVQ1_BLOCK_INTRA_LEN
Definition: svq1.h:52
SVQ1EncContext::m
MpegEncContext m
Definition: svq1enc.c:61
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
MECmpContext
Definition: me_cmp.h:55
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_svq1enc_init_ppc
av_cold void ff_svq1enc_init_ppc(SVQ1EncDSPContext *c)
Definition: svq1enc_altivec.c:74
NULL
#define NULL
Definition: coverity.c:32
SVQ1EncContext::current_picture
AVFrame * current_picture
Definition: svq1enc.c:65
VE
#define VE
Definition: svq1enc.c:736
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
SVQ1EncContext::c_block_height
int c_block_height
Definition: svq1enc.c:85
ME_MAP_SIZE
#define ME_MAP_SIZE
Definition: motion_est.h:38
FF_ME_XONE
#define FF_ME_XONE
Definition: motion_est.h:42
svq1_write_header
static void svq1_write_header(SVQ1EncContext *s, PutBitContext *pb, int frame_type)
Definition: svq1enc.c:103
svq1_encode_end
static av_cold int svq1_encode_end(AVCodecContext *avctx)
Definition: svq1enc.c:547
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:417
SVQ1EncContext::rd_total
int64_t rd_total
Definition: svq1enc.c:94
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
ff_encode_alloc_frame
int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame)
Allocate buffers for a frame.
Definition: encode.c:808
SVQ1EncContext::dummy
uint32_t * dummy
Definition: svq1enc.c:90
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
SVQ1EncContext::quality
int quality
Definition: svq1enc.c:70
AVPacket::size
int size
Definition: packet.h:516
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:643
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:87
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:485
size
int size
Definition: twinvq_data.h:10344
SVQ1EncContext::reorder_pb
PutBitContext reorder_pb[6]
Definition: svq1enc.c:74
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:312
SVQ1EncContext::mb_type
uint16_t * mb_type
Definition: svq1enc.c:89
frame.h
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:80
height
#define height
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
SVQ1_BLOCK_INTER_CODE
#define SVQ1_BLOCK_INTER_CODE
Definition: svq1.h:49
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:521
SVQ1EncContext::avctx
AVCodecContext * avctx
Definition: svq1enc.c:62
AV_CODEC_ID_SVQ1
@ AV_CODEC_ID_SVQ1
Definition: codec_id.h:74
emms.h
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:245
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:542
SVQ1EncContext::mecc
MECmpContext mecc
Definition: svq1enc.c:63
ff_svq1enc_init_x86
void ff_svq1enc_init_x86(SVQ1EncDSPContext *c)
Definition: svq1enc_init.c:30
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
ff_h263_encode_init
void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:816
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
SVQ1EncContext::motion_val8
int16_t(*[3] motion_val8)[2]
Definition: svq1enc.c:91
ff_init_me
int ff_init_me(MpegEncContext *s)
Definition: motion_est.c:308
AVCodecContext::height
int height
Definition: avcodec.h:621
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:658
SVQ1EncContext::hdsp
HpelDSPContext hdsp
Definition: svq1enc.c:64
svq1_intra_codebook_sum
static const int8_t svq1_intra_codebook_sum[4][16 *6]
Definition: svq1enc_cb.h:59
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ff_svq1_inter_multistage_vlc
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]
Definition: svq1_vlc.h:50
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2118
SVQ1EncContext::y_block_width
int y_block_width
Definition: svq1enc.c:80
write_ident
static av_cold int write_ident(AVCodecContext *avctx, const char *ident)
Definition: svq1enc.c:578
SVQ1EncDSPContext
Definition: svq1encdsp.h:26
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
options
static const AVOption options[]
Definition: svq1enc.c:737
me_cmp.h
SVQ1EncContext::motion_val16
int16_t(*[3] motion_val16)[2]
Definition: svq1enc.c:92
ff_fix_long_mvs
void ff_fix_long_mvs(MpegEncContext *s, uint8_t *field_select_table, int field_select, int16_t(*mv_table)[2], int f_code, int type, int truncate)
Definition: motion_est.c:1704
AVCodecContext
main external API structure.
Definition: avcodec.h:441
ff_estimate_p_frame_motion
void ff_estimate_p_frame_motion(MpegEncContext *s, int mb_x, int mb_y)
Definition: motion_est.c:890
FF_MPV_OPT_FLAGS
#define FF_MPV_OPT_FLAGS
Definition: mpegvideoenc.h:64
ff_svq1_intra_mean_vlc
const uint16_t ff_svq1_intra_mean_vlc[256][2]
Definition: svq1_vlc.h:67
CANDIDATE_MB_TYPE_INTRA
#define CANDIDATE_MB_TYPE_INTRA
Definition: mpegutils.h:97
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
svq1.h
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
temp
else temp
Definition: vf_mcdeint.c:263
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:862
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
packet_internal.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:338
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:96
AVPacket
This structure stores compressed data.
Definition: packet.h:492
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:468
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:621
OFFSET
#define OFFSET(x)
Definition: svq1enc.c:735
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:385
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:72
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
svq1_encode_frame
static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: svq1enc.c:655
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2038
svq1enc_class
static const AVClass svq1enc_class
Definition: svq1enc.c:746
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:422
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:232
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:67
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:61
QUALITY_THRESHOLD
#define QUALITY_THRESHOLD
Definition: svq1enc.c:137
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
FF_ME_ZERO
#define FF_ME_ZERO
Definition: motion_est.h:40
h263.h