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 "svq1.h"
41 #include "svq1enc.h"
42 #include "svq1enc_cb.h"
43 #include "libavutil/avassert.h"
44 
45 
47 {
48  int i;
49 
50  /* frame code */
51  put_bits(&s->pb, 22, 0x20);
52 
53  /* temporal reference (sure hope this is a "don't care") */
54  put_bits(&s->pb, 8, 0x00);
55 
56  /* frame type */
57  put_bits(&s->pb, 2, frame_type - 1);
58 
60  /* no checksum since frame code is 0x20 */
61  /* no embedded string either */
62  /* output 5 unknown bits (2 + 2 + 1) */
63  put_bits(&s->pb, 5, 2); /* 2 needed by quicktime decoder */
64 
67  s->frame_width, s->frame_height);
68  put_bits(&s->pb, 3, i);
69 
70  if (i == 7) {
71  put_bits(&s->pb, 12, s->frame_width);
72  put_bits(&s->pb, 12, s->frame_height);
73  }
74  }
75 
76  /* no checksum or extra data (next 2 bits get 0) */
77  put_bits(&s->pb, 2, 0);
78 }
79 
80 #define QUALITY_THRESHOLD 100
81 #define THRESHOLD_MULTIPLIER 0.6
82 
83 static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
84  intptr_t size)
85 {
86  int score = 0, i;
87 
88  for (i = 0; i < size; i++)
89  score += (pix1[i] - pix2[i]) * (pix1[i] - pix2[i]);
90  return score;
91 }
92 
93 static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref,
94  uint8_t *decoded, int stride, unsigned level,
95  int threshold, int lambda, int intra)
96 {
97  int count, y, x, i, j, split, best_mean, best_score, best_count;
98  int best_vector[6];
99  int block_sum[7] = { 0, 0, 0, 0, 0, 0 };
100  int w = 2 << (level + 2 >> 1);
101  int h = 2 << (level + 1 >> 1);
102  int size = w * h;
103  int16_t (*block)[256] = s->encoded_block_levels[level];
104  const int8_t *codebook_sum, *codebook;
105  const uint16_t(*mean_vlc)[2];
106  const uint8_t(*multistage_vlc)[2];
107 
108  best_score = 0;
109  // FIXME: Optimize, this does not need to be done multiple times.
110  if (intra) {
111  // level is 5 when encode_block is called from svq1_encode_plane
112  // and always < 4 when called recursively from this function.
113  codebook_sum = level < 4 ? svq1_intra_codebook_sum[level] : NULL;
115  mean_vlc = ff_svq1_intra_mean_vlc;
116  multistage_vlc = ff_svq1_intra_multistage_vlc[level];
117  for (y = 0; y < h; y++) {
118  for (x = 0; x < w; x++) {
119  int v = src[x + y * stride];
120  block[0][x + w * y] = v;
121  best_score += v * v;
122  block_sum[0] += v;
123  }
124  }
125  } else {
126  // level is 5 or < 4, see above for details.
127  codebook_sum = level < 4 ? svq1_inter_codebook_sum[level] : NULL;
129  mean_vlc = ff_svq1_inter_mean_vlc + 256;
130  multistage_vlc = ff_svq1_inter_multistage_vlc[level];
131  for (y = 0; y < h; y++) {
132  for (x = 0; x < w; x++) {
133  int v = src[x + y * stride] - ref[x + y * stride];
134  block[0][x + w * y] = v;
135  best_score += v * v;
136  block_sum[0] += v;
137  }
138  }
139  }
140 
141  best_count = 0;
142  best_score -= (int)((unsigned)block_sum[0] * block_sum[0] >> (level + 3));
143  best_mean = block_sum[0] + (size >> 1) >> (level + 3);
144 
145  if (level < 4) {
146  for (count = 1; count < 7; count++) {
147  int best_vector_score = INT_MAX;
148  int best_vector_sum = -999, best_vector_mean = -999;
149  const int stage = count - 1;
150  const int8_t *vector;
151 
152  for (i = 0; i < 16; i++) {
153  int sum = codebook_sum[stage * 16 + i];
154  int sqr, diff, score;
155 
156  vector = codebook + stage * size * 16 + i * size;
157  sqr = s->ssd_int8_vs_int16(vector, block[stage], size);
158  diff = block_sum[stage] - sum;
159  score = sqr - (diff * (int64_t)diff >> (level + 3)); // FIXME: 64 bits slooow
160  if (score < best_vector_score) {
161  int mean = diff + (size >> 1) >> (level + 3);
162  av_assert2(mean > -300 && mean < 300);
163  mean = av_clip(mean, intra ? 0 : -256, 255);
164  best_vector_score = score;
165  best_vector[stage] = i;
166  best_vector_sum = sum;
167  best_vector_mean = mean;
168  }
169  }
170  av_assert0(best_vector_mean != -999);
171  vector = codebook + stage * size * 16 + best_vector[stage] * size;
172  for (j = 0; j < size; j++)
173  block[stage + 1][j] = block[stage][j] - vector[j];
174  block_sum[stage + 1] = block_sum[stage] - best_vector_sum;
175  best_vector_score += lambda *
176  (+1 + 4 * count +
177  multistage_vlc[1 + count][1]
178  + mean_vlc[best_vector_mean][1]);
179 
180  if (best_vector_score < best_score) {
181  best_score = best_vector_score;
182  best_count = count;
183  best_mean = best_vector_mean;
184  }
185  }
186  }
187 
188  split = 0;
189  if (best_score > threshold && level) {
190  int score = 0;
191  int offset = level & 1 ? stride * h / 2 : w / 2;
192  PutBitContext backup[6];
193 
194  for (i = level - 1; i >= 0; i--)
195  backup[i] = s->reorder_pb[i];
196  score += encode_block(s, src, ref, decoded, stride, level - 1,
197  threshold >> 1, lambda, intra);
198  score += encode_block(s, src + offset, ref + offset, decoded + offset,
199  stride, level - 1, threshold >> 1, lambda, intra);
200  score += lambda;
201 
202  if (score < best_score) {
203  best_score = score;
204  split = 1;
205  } else {
206  for (i = level - 1; i >= 0; i--)
207  s->reorder_pb[i] = backup[i];
208  }
209  }
210  if (level > 0)
211  put_bits(&s->reorder_pb[level], 1, split);
212 
213  if (!split) {
214  av_assert1(best_mean >= 0 && best_mean < 256 || !intra);
215  av_assert1(best_mean >= -256 && best_mean < 256);
216  av_assert1(best_count >= 0 && best_count < 7);
217  av_assert1(level < 4 || best_count == 0);
218 
219  /* output the encoding */
220  put_bits(&s->reorder_pb[level],
221  multistage_vlc[1 + best_count][1],
222  multistage_vlc[1 + best_count][0]);
223  put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
224  mean_vlc[best_mean][0]);
225 
226  for (i = 0; i < best_count; i++) {
227  av_assert2(best_vector[i] >= 0 && best_vector[i] < 16);
228  put_bits(&s->reorder_pb[level], 4, best_vector[i]);
229  }
230 
231  for (y = 0; y < h; y++)
232  for (x = 0; x < w; x++)
233  decoded[x + y * stride] = src[x + y * stride] -
234  block[best_count][x + w * y] +
235  best_mean;
236  }
237 
238  return best_score;
239 }
240 
242  s->block_index[0]= s->b8_stride*(s->mb_y*2 ) + s->mb_x*2;
243  s->block_index[1]= s->b8_stride*(s->mb_y*2 ) + 1 + s->mb_x*2;
244  s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) + s->mb_x*2;
245  s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) + 1 + s->mb_x*2;
246  s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x;
247  s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x;
248 }
249 
250 static int svq1_encode_plane(SVQ1EncContext *s, int plane,
251  const unsigned char *src_plane,
252  unsigned char *ref_plane,
253  unsigned char *decoded_plane,
254  int width, int height, int src_stride, int stride)
255 {
256  int x, y;
257  int i;
258  int block_width, block_height;
259  int level;
260  int threshold[6];
261  uint8_t *src = s->scratchbuf + stride * 32;
262  const int lambda = (s->quality * s->quality) >>
263  (2 * FF_LAMBDA_SHIFT);
264 
265  /* figure out the acceptable level thresholds in advance */
266  threshold[5] = QUALITY_THRESHOLD;
267  for (level = 4; level >= 0; level--)
268  threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
269 
270  block_width = (width + 15) / 16;
271  block_height = (height + 15) / 16;
272 
273  if (s->pict_type == AV_PICTURE_TYPE_P) {
274  s->m.avctx = s->avctx;
275  s->m.current_picture_ptr = &s->m.current_picture;
276  s->m.last_picture_ptr = &s->m.last_picture;
277  s->m.last_picture.f->data[0] = ref_plane;
278  s->m.linesize =
279  s->m.last_picture.f->linesize[0] =
280  s->m.new_picture->linesize[0] =
281  s->m.current_picture.f->linesize[0] = stride;
282  s->m.width = width;
283  s->m.height = height;
284  s->m.mb_width = block_width;
285  s->m.mb_height = block_height;
286  s->m.mb_stride = s->m.mb_width + 1;
287  s->m.b8_stride = 2 * s->m.mb_width + 1;
288  s->m.f_code = 1;
289  s->m.pict_type = s->pict_type;
290  s->m.motion_est = s->motion_est;
291  s->m.me.scene_change_score = 0;
292  // s->m.out_format = FMT_H263;
293  // s->m.unrestricted_mv = 1;
294  s->m.lambda = s->quality;
295  s->m.qscale = s->m.lambda * 139 +
296  FF_LAMBDA_SCALE * 64 >>
297  FF_LAMBDA_SHIFT + 7;
298  s->m.lambda2 = s->m.lambda * s->m.lambda +
299  FF_LAMBDA_SCALE / 2 >>
301 
302  if (!s->motion_val8[plane]) {
303  s->motion_val8[plane] = av_mallocz((s->m.b8_stride *
304  block_height * 2 + 2) *
305  2 * sizeof(int16_t));
306  s->motion_val16[plane] = av_mallocz((s->m.mb_stride *
307  (block_height + 2) + 1) *
308  2 * sizeof(int16_t));
309  if (!s->motion_val8[plane] || !s->motion_val16[plane])
310  return AVERROR(ENOMEM);
311  }
312 
313  s->m.mb_type = s->mb_type;
314 
315  // dummies, to avoid segfaults
316  s->m.mb_mean = (uint8_t *)s->dummy;
317  s->m.mb_var = (uint16_t *)s->dummy;
318  s->m.mc_mb_var = (uint16_t *)s->dummy;
319  s->m.current_picture.mb_type = s->dummy;
320 
321  s->m.current_picture.motion_val[0] = s->motion_val8[plane] + 2;
322  s->m.p_mv_table = s->motion_val16[plane] +
323  s->m.mb_stride + 1;
324  s->m.mecc = s->mecc; // move
325  ff_init_me(&s->m);
326 
327  s->m.me.dia_size = s->avctx->dia_size;
328  s->m.first_slice_line = 1;
329  for (y = 0; y < block_height; y++) {
330  s->m.new_picture->data[0] = src - y * 16 * stride; // ugly
331  s->m.mb_y = y;
332 
333  for (i = 0; i < 16 && i + 16 * y < height; i++) {
334  memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
335  width);
336  for (x = width; x < 16 * block_width; x++)
337  src[i * stride + x] = src[i * stride + x - 1];
338  }
339  for (; i < 16 && i + 16 * y < 16 * block_height; i++)
340  memcpy(&src[i * stride], &src[(i - 1) * stride],
341  16 * block_width);
342 
343  for (x = 0; x < block_width; x++) {
344  s->m.mb_x = x;
345  init_block_index(&s->m);
346 
347  ff_estimate_p_frame_motion(&s->m, x, y);
348  }
349  s->m.first_slice_line = 0;
350  }
351 
353  ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,
355  }
356 
357  s->m.first_slice_line = 1;
358  for (y = 0; y < block_height; y++) {
359  for (i = 0; i < 16 && i + 16 * y < height; i++) {
360  memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
361  width);
362  for (x = width; x < 16 * block_width; x++)
363  src[i * stride + x] = src[i * stride + x - 1];
364  }
365  for (; i < 16 && i + 16 * y < 16 * block_height; i++)
366  memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);
367 
368  s->m.mb_y = y;
369  for (x = 0; x < block_width; x++) {
370  uint8_t reorder_buffer[2][6][7 * 32];
371  int count[2][6];
372  int offset = y * 16 * stride + x * 16;
373  uint8_t *decoded = decoded_plane + offset;
374  const uint8_t *ref = ref_plane + offset;
375  int score[4] = { 0, 0, 0, 0 }, best;
376  uint8_t *temp = s->scratchbuf;
377 
378  if (put_bytes_left(&s->pb, 0) < 3000) { // FIXME: check size
379  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
380  return -1;
381  }
382 
383  s->m.mb_x = x;
384  init_block_index(&s->m);
385 
386  if (s->pict_type == AV_PICTURE_TYPE_I ||
387  (s->m.mb_type[x + y * s->m.mb_stride] &
389  for (i = 0; i < 6; i++)
390  init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
391  7 * 32);
392  if (s->pict_type == AV_PICTURE_TYPE_P) {
393  const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
394  put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
395  score[0] = vlc[1] * lambda;
396  }
397  score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,
398  5, 64, lambda, 1);
399  for (i = 0; i < 6; i++) {
400  count[0][i] = put_bits_count(&s->reorder_pb[i]);
401  flush_put_bits(&s->reorder_pb[i]);
402  }
403  } else
404  score[0] = INT_MAX;
405 
406  best = 0;
407 
408  if (s->pict_type == AV_PICTURE_TYPE_P) {
409  const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];
410  int mx, my, pred_x, pred_y, dxy;
411  int16_t *motion_ptr;
412 
413  motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
414  if (s->m.mb_type[x + y * s->m.mb_stride] &
416  for (i = 0; i < 6; i++)
417  init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],
418  7 * 32);
419 
420  put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
421 
422  s->m.pb = s->reorder_pb[5];
423  mx = motion_ptr[0];
424  my = motion_ptr[1];
425  av_assert1(mx >= -32 && mx <= 31);
426  av_assert1(my >= -32 && my <= 31);
427  av_assert1(pred_x >= -32 && pred_x <= 31);
428  av_assert1(pred_y >= -32 && pred_y <= 31);
429  ff_h263_encode_motion(&s->m.pb, mx - pred_x, 1);
430  ff_h263_encode_motion(&s->m.pb, my - pred_y, 1);
431  s->reorder_pb[5] = s->m.pb;
432  score[1] += lambda * put_bits_count(&s->reorder_pb[5]);
433 
434  dxy = (mx & 1) + 2 * (my & 1);
435 
436  s->hdsp.put_pixels_tab[0][dxy](temp + 16*stride,
437  ref + (mx >> 1) +
438  stride * (my >> 1),
439  stride, 16);
440 
441  score[1] += encode_block(s, src + 16 * x, temp + 16*stride,
442  decoded, stride, 5, 64, lambda, 0);
443  best = score[1] <= score[0];
444 
446  score[2] = s->mecc.sse[0](NULL, src + 16 * x, ref,
447  stride, 16);
448  score[2] += vlc[1] * lambda;
449  if (score[2] < score[best] && mx == 0 && my == 0) {
450  best = 2;
451  s->hdsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
452  put_bits(&s->pb, vlc[1], vlc[0]);
453  }
454  }
455 
456  if (best == 1) {
457  for (i = 0; i < 6; i++) {
458  count[1][i] = put_bits_count(&s->reorder_pb[i]);
459  flush_put_bits(&s->reorder_pb[i]);
460  }
461  } else {
462  motion_ptr[0] =
463  motion_ptr[1] =
464  motion_ptr[2] =
465  motion_ptr[3] =
466  motion_ptr[0 + 2 * s->m.b8_stride] =
467  motion_ptr[1 + 2 * s->m.b8_stride] =
468  motion_ptr[2 + 2 * s->m.b8_stride] =
469  motion_ptr[3 + 2 * s->m.b8_stride] = 0;
470  }
471  }
472 
473  s->rd_total += score[best];
474 
475  if (best != 2)
476  for (i = 5; i >= 0; i--)
477  ff_copy_bits(&s->pb, reorder_buffer[best][i],
478  count[best][i]);
479  if (best == 0)
480  s->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
481  }
482  s->m.first_slice_line = 0;
483  }
484  return 0;
485 }
486 
488 {
489  SVQ1EncContext *const s = avctx->priv_data;
490  int i;
491 
492  if (avctx->frame_number)
493  av_log(avctx, AV_LOG_DEBUG, "RD: %f\n",
494  s->rd_total / (double)(avctx->width * avctx->height *
495  avctx->frame_number));
496 
497  s->m.mb_type = NULL;
498  ff_mpv_common_end(&s->m);
499 
500  av_freep(&s->m.me.scratchpad);
501  av_freep(&s->m.me.map);
502  av_freep(&s->m.me.score_map);
503  av_freep(&s->mb_type);
504  av_freep(&s->dummy);
505  av_freep(&s->scratchbuf);
506 
507  for (i = 0; i < 3; i++) {
508  av_freep(&s->motion_val8[i]);
509  av_freep(&s->motion_val16[i]);
510  }
511 
512  av_frame_free(&s->current_picture);
513  av_frame_free(&s->last_picture);
514 
515  return 0;
516 }
517 
519 {
520  SVQ1EncContext *const s = avctx->priv_data;
521  int ret;
522 
523  if (avctx->width >= 4096 || avctx->height >= 4096) {
524  av_log(avctx, AV_LOG_ERROR, "Dimensions too large, maximum is 4095x4095\n");
525  return AVERROR(EINVAL);
526  }
527 
528  ff_hpeldsp_init(&s->hdsp, avctx->flags);
529  ff_me_cmp_init(&s->mecc, avctx);
530  ff_mpegvideoencdsp_init(&s->m.mpvencdsp, avctx);
531 
532  s->current_picture = av_frame_alloc();
533  s->last_picture = av_frame_alloc();
534  if (!s->current_picture || !s->last_picture) {
535  return AVERROR(ENOMEM);
536  }
537 
538  s->frame_width = avctx->width;
539  s->frame_height = avctx->height;
540 
541  s->y_block_width = (s->frame_width + 15) / 16;
542  s->y_block_height = (s->frame_height + 15) / 16;
543 
544  s->c_block_width = (s->frame_width / 4 + 15) / 16;
545  s->c_block_height = (s->frame_height / 4 + 15) / 16;
546 
547  s->avctx = avctx;
548  s->m.avctx = avctx;
549 
550  if ((ret = ff_mpv_common_init(&s->m)) < 0) {
551  return ret;
552  }
553 
554  s->m.picture_structure = PICT_FRAME;
555  s->m.me.temp =
556  s->m.me.scratchpad = av_mallocz((avctx->width + 64) *
557  2 * 16 * 2 * sizeof(uint8_t));
558  s->m.me.map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
559  s->m.me.score_map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
560  s->mb_type = av_mallocz((s->y_block_width + 1) *
561  s->y_block_height * sizeof(int16_t));
562  s->dummy = av_mallocz((s->y_block_width + 1) *
563  s->y_block_height * sizeof(int32_t));
564  s->ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
565 
566  if (!s->m.me.temp || !s->m.me.scratchpad || !s->m.me.map ||
567  !s->m.me.score_map || !s->mb_type || !s->dummy) {
568  return AVERROR(ENOMEM);
569  }
570 
571 #if ARCH_PPC
573 #elif ARCH_X86
575 #endif
576 
577  ff_h263_encode_init(&s->m); // mv_penalty
578 
579  return 0;
580 }
581 
583  const AVFrame *pict, int *got_packet)
584 {
585  SVQ1EncContext *const s = avctx->priv_data;
586  int i, ret;
587 
588  ret = ff_alloc_packet(avctx, pkt, s->y_block_width * s->y_block_height *
590  if (ret < 0)
591  return ret;
592 
593  if (avctx->pix_fmt != AV_PIX_FMT_YUV410P) {
594  av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
595  return -1;
596  }
597 
598  if (!s->current_picture->data[0]) {
599  if ((ret = ff_encode_alloc_frame(avctx, s->current_picture)) < 0) {
600  return ret;
601  }
602  }
603  if (!s->last_picture->data[0]) {
604  ret = ff_encode_alloc_frame(avctx, s->last_picture);
605  if (ret < 0)
606  return ret;
607  }
608  if (!s->scratchbuf) {
609  s->scratchbuf = av_malloc_array(s->current_picture->linesize[0], 16 * 3);
610  if (!s->scratchbuf)
611  return AVERROR(ENOMEM);
612  }
613 
614  FFSWAP(AVFrame*, s->current_picture, s->last_picture);
615 
616  init_put_bits(&s->pb, pkt->data, pkt->size);
617 
618  if (avctx->gop_size && (avctx->frame_number % avctx->gop_size))
619  s->pict_type = AV_PICTURE_TYPE_P;
620  else
621  s->pict_type = AV_PICTURE_TYPE_I;
622  s->quality = pict->quality;
623 
624  ff_side_data_set_encoder_stats(pkt, pict->quality, NULL, 0, s->pict_type);
625 
626  svq1_write_header(s, s->pict_type);
627  for (i = 0; i < 3; i++) {
628  int ret = svq1_encode_plane(s, i,
629  pict->data[i],
630  s->last_picture->data[i],
631  s->current_picture->data[i],
632  s->frame_width / (i ? 4 : 1),
633  s->frame_height / (i ? 4 : 1),
634  pict->linesize[i],
635  s->current_picture->linesize[i]);
636  emms_c();
637  if (ret < 0) {
638  int j;
639  for (j = 0; j < i; j++) {
640  av_freep(&s->motion_val8[j]);
641  av_freep(&s->motion_val16[j]);
642  }
643  av_freep(&s->scratchbuf);
644  return -1;
645  }
646  }
647 
648  // align_put_bits(&s->pb);
649  while (put_bits_count(&s->pb) & 31)
650  put_bits(&s->pb, 1, 0);
651 
652  flush_put_bits(&s->pb);
653 
654  pkt->size = put_bytes_output(&s->pb);
655  if (s->pict_type == AV_PICTURE_TYPE_I)
657  *got_packet = 1;
658 
659  return 0;
660 }
661 
662 #define OFFSET(x) offsetof(struct SVQ1EncContext, x)
663 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
664 static const AVOption options[] = {
665  { "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"},
666  { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
667  { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
668  { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
669 
670  { NULL },
671 };
672 
673 static const AVClass svq1enc_class = {
674  .class_name = "svq1enc",
675  .item_name = av_default_item_name,
676  .option = options,
677  .version = LIBAVUTIL_VERSION_INT,
678 };
679 
681  .p.name = "svq1",
682  .p.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
683  .p.type = AVMEDIA_TYPE_VIDEO,
684  .p.id = AV_CODEC_ID_SVQ1,
685  .priv_data_size = sizeof(SVQ1EncContext),
686  .p.priv_class = &svq1enc_class,
687  .init = svq1_encode_init,
689  .close = svq1_encode_end,
690  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
691  AV_PIX_FMT_NONE },
692  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
693 };
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:93
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:743
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:206
av_clip
#define av_clip
Definition: common.h:95
THRESHOLD_MULTIPLIER
#define THRESHOLD_MULTIPLIER
Definition: svq1enc.c:81
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:41
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
svq1enc_cb.h
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
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
SVQ1EncContext
Definition: svq1enc.h:35
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:680
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:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
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
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
encode.h
FFCodec
Definition: codec_internal.h:118
mpegvideo.h
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
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
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
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:122
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:872
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:190
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:478
init_block_index
static void init_block_index(MpegEncContext *s)
Definition: svq1enc.c:241
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:269
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:83
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
svq1_encode_init
static av_cold int svq1_encode_init(AVCodecContext *avctx)
Definition: svq1enc.c:518
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:879
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
width
#define width
MAX_MB_BYTES
#define MAX_MB_BYTES
Definition: mpegutils.h:40
s
#define s(width, name)
Definition: cbs_vp9.c:256
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
PutBitContext
Definition: put_bits.h:50
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
sqr
static double sqr(double x)
Definition: af_adynamicequalizer.c:84
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
SVQ1_BLOCK_INTRA
#define SVQ1_BLOCK_INTRA
Definition: svq1.h:43
VE
#define VE
Definition: svq1enc.c:663
svq1_encode_plane
static int svq1_encode_plane(SVQ1EncContext *s, int plane, 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:250
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
SVQ1_BLOCK_SKIP
#define SVQ1_BLOCK_SKIP
Definition: svq1.h:40
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_encode_end
static av_cold int svq1_encode_end(AVCodecContext *avctx)
Definition: svq1enc.c:487
ff_svq1_inter_codebooks
const int8_t *const ff_svq1_inter_codebooks[6]
Definition: svq1_cb.h:776
ff_encode_alloc_frame
int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame)
Allocate buffers for a frame.
Definition: encode.c:680
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:593
codec_internal.h
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:461
size
int size
Definition: twinvq_data.h:10344
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
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
AV_CODEC_ID_SVQ1
@ AV_CODEC_ID_SVQ1
Definition: codec_id.h:72
svq1enc.h
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
svq1_write_header
static void svq1_write_header(SVQ1EncContext *s, int frame_type)
Definition: svq1enc.c:46
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
ff_svq1enc_init_x86
void ff_svq1enc_init_x86(SVQ1EncContext *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:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
ff_init_me
int ff_init_me(MpegEncContext *s)
Definition: motion_est.c:308
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
SVQ1_BLOCK_INTER
#define SVQ1_BLOCK_INTER
Definition: svq1.h:41
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
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:664
me_cmp.h
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:398
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_block_type_vlc
const uint8_t ff_svq1_block_type_vlc[4][2]
Definition: svq1_vlc.h:27
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
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1046
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
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:571
OFFSET
#define OFFSET(x)
Definition: svq1enc.c:662
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:370
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:582
h
h
Definition: vp9dsp_template.c:2038
ff_svq1enc_init_ppc
av_cold void ff_svq1enc_init_ppc(SVQ1EncContext *c)
Definition: svq1enc_altivec.c:74
svq1enc_class
static const AVClass svq1enc_class
Definition: svq1enc.c:673
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:155
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:62
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:80
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