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