FFmpeg: libavcodec/svq1enc.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /