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