Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * SVQ1 Encoder | ||
3 | * Copyright (C) 2004 Mike Melanson <melanson@pcisys.net> | ||
4 | * | ||
5 | * This file is part of FFmpeg. | ||
6 | * | ||
7 | * FFmpeg is free software; you can redistribute it and/or | ||
8 | * modify it under the terms of the GNU Lesser General Public | ||
9 | * License as published by the Free Software Foundation; either | ||
10 | * version 2.1 of the License, or (at your option) any later version. | ||
11 | * | ||
12 | * FFmpeg is distributed in the hope that it will be useful, | ||
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
15 | * Lesser General Public License for more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU Lesser General Public | ||
18 | * License along with FFmpeg; if not, write to the Free Software | ||
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
20 | */ | ||
21 | |||
22 | /** | ||
23 | * @file | ||
24 | * Sorenson Vector Quantizer #1 (SVQ1) video codec. | ||
25 | * For more information of the SVQ1 algorithm, visit: | ||
26 | * http://www.pcisys.net/~melanson/codecs/ | ||
27 | */ | ||
28 | |||
29 | #include "libavutil/emms.h" | ||
30 | #include "libavutil/mem.h" | ||
31 | #include "avcodec.h" | ||
32 | #include "codec_internal.h" | ||
33 | #include "encode.h" | ||
34 | #include "hpeldsp.h" | ||
35 | #include "me_cmp.h" | ||
36 | #include "mpegvideo.h" | ||
37 | #include "h263.h" | ||
38 | #include "h263enc.h" | ||
39 | #include "internal.h" | ||
40 | #include "mpegutils.h" | ||
41 | #include "packet_internal.h" | ||
42 | #include "put_bits.h" | ||
43 | #include "svq1.h" | ||
44 | #include "svq1encdsp.h" | ||
45 | #include "svq1enc_cb.h" | ||
46 | #include "version.h" | ||
47 | |||
48 | #include "libavutil/avassert.h" | ||
49 | #include "libavutil/frame.h" | ||
50 | #include "libavutil/mem_internal.h" | ||
51 | |||
52 | // Workaround for GCC bug 102513 | ||
53 | #if AV_GCC_VERSION_AT_LEAST(10, 0) && AV_GCC_VERSION_AT_MOST(12, 0) \ | ||
54 | && !defined(__clang__) && !defined(__INTEL_COMPILER) | ||
55 | #pragma GCC optimize ("no-ipa-cp-clone") | ||
56 | #endif | ||
57 | |||
58 | typedef struct SVQ1EncContext { | ||
59 | /* FIXME: Needed for motion estimation, should not be used for anything | ||
60 | * else, the idea is to make the motion estimation eventually independent | ||
61 | * of MPVEncContext, so this will be removed then. */ | ||
62 | MPVEncContext m; | ||
63 | AVCodecContext *avctx; | ||
64 | MECmpContext mecc; | ||
65 | AVFrame *current_picture; | ||
66 | AVFrame *last_picture; | ||
67 | |||
68 | /* Some compression statistics */ | ||
69 | enum AVPictureType pict_type; | ||
70 | int quality; | ||
71 | |||
72 | /* why ooh why this sick breadth first order, | ||
73 | * everything is slower and more complex */ | ||
74 | PutBitContext reorder_pb[6]; | ||
75 | |||
76 | int frame_width; | ||
77 | int frame_height; | ||
78 | |||
79 | /* Y plane block dimensions */ | ||
80 | int y_block_width; | ||
81 | int y_block_height; | ||
82 | |||
83 | DECLARE_ALIGNED(16, int16_t, encoded_block_levels)[6][7][256]; | ||
84 | |||
85 | uint16_t *mb_type; | ||
86 | uint32_t *dummy; | ||
87 | int16_t (*motion_val8[3])[2]; | ||
88 | int16_t (*motion_val16[3])[2]; | ||
89 | |||
90 | int64_t rd_total; | ||
91 | |||
92 | uint8_t *scratchbuf; | ||
93 | |||
94 | SVQ1EncDSPContext svq1encdsp; | ||
95 | } SVQ1EncContext; | ||
96 | |||
97 | 200 | static void svq1_write_header(SVQ1EncContext *s, PutBitContext *pb, int frame_type) | |
98 | { | ||
99 | int i; | ||
100 | |||
101 | /* frame code */ | ||
102 | 200 | put_bits(pb, 22, 0x20); | |
103 | |||
104 | /* temporal reference (sure hope this is a "don't care") */ | ||
105 | 200 | put_bits(pb, 8, 0x00); | |
106 | |||
107 | /* frame type */ | ||
108 | 200 | put_bits(pb, 2, frame_type - 1); | |
109 | |||
110 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 180 times.
|
200 | if (frame_type == AV_PICTURE_TYPE_I) { |
111 | /* no checksum since frame code is 0x20 */ | ||
112 | /* no embedded string either */ | ||
113 | /* output 5 unknown bits (2 + 2 + 1) */ | ||
114 | 20 | put_bits(pb, 5, 2); /* 2 needed by quicktime decoder */ | |
115 | |||
116 | 20 | i = ff_match_2uint16(ff_svq1_frame_size_table, | |
117 | FF_ARRAY_ELEMS(ff_svq1_frame_size_table), | ||
118 | s->frame_width, s->frame_height); | ||
119 | 20 | put_bits(pb, 3, i); | |
120 | |||
121 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 15 times.
|
20 | if (i == 7) { |
122 | 5 | put_bits(pb, 12, s->frame_width); | |
123 | 5 | put_bits(pb, 12, s->frame_height); | |
124 | } | ||
125 | } | ||
126 | |||
127 | /* no checksum or extra data (next 2 bits get 0) */ | ||
128 | 200 | put_bits(pb, 2, 0); | |
129 | 200 | } | |
130 | |||
131 | #define QUALITY_THRESHOLD 100 | ||
132 | #define THRESHOLD_MULTIPLIER 0.6 | ||
133 | |||
134 | 4302522 | static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref, | |
135 | uint8_t *decoded, int stride, unsigned level, | ||
136 | int threshold, int lambda, int intra) | ||
137 | { | ||
138 | int count, y, x, i, j, split, best_mean, best_score, best_count; | ||
139 | int best_vector[6]; | ||
140 | 4302522 | int block_sum[7] = { 0, 0, 0, 0, 0, 0 }; | |
141 | 4302522 | int w = 2 << (level + 2 >> 1); | |
142 | 4302522 | int h = 2 << (level + 1 >> 1); | |
143 | 4302522 | int size = w * h; | |
144 | 4302522 | int16_t (*block)[256] = s->encoded_block_levels[level]; | |
145 | const int8_t *codebook_sum, *codebook; | ||
146 | const uint16_t(*mean_vlc)[2]; | ||
147 | const uint8_t(*multistage_vlc)[2]; | ||
148 | |||
149 | 4302522 | best_score = 0; | |
150 | // FIXME: Optimize, this does not need to be done multiple times. | ||
151 |
2/2✓ Branch 0 taken 643715 times.
✓ Branch 1 taken 3658807 times.
|
4302522 | if (intra) { |
152 | // level is 5 when encode_block is called from svq1_encode_plane | ||
153 | // and always < 4 when called recursively from this function. | ||
154 |
2/2✓ Branch 0 taken 612686 times.
✓ Branch 1 taken 31029 times.
|
643715 | codebook_sum = level < 4 ? svq1_intra_codebook_sum[level] : NULL; |
155 | 643715 | codebook = ff_svq1_intra_codebooks[level]; | |
156 | 643715 | mean_vlc = ff_svq1_intra_mean_vlc; | |
157 | 643715 | multistage_vlc = ff_svq1_intra_multistage_vlc[level]; | |
158 |
2/2✓ Branch 0 taken 2296676 times.
✓ Branch 1 taken 643715 times.
|
2940391 | for (y = 0; y < h; y++) { |
159 |
2/2✓ Branch 0 taken 15798160 times.
✓ Branch 1 taken 2296676 times.
|
18094836 | for (x = 0; x < w; x++) { |
160 | 15798160 | int v = src[x + y * stride]; | |
161 | 15798160 | block[0][x + w * y] = v; | |
162 | 15798160 | best_score += v * v; | |
163 | 15798160 | block_sum[0] += v; | |
164 | } | ||
165 | } | ||
166 | } else { | ||
167 | // level is 5 or < 4, see above for details. | ||
168 |
2/2✓ Branch 0 taken 3483018 times.
✓ Branch 1 taken 175789 times.
|
3658807 | codebook_sum = level < 4 ? svq1_inter_codebook_sum[level] : NULL; |
169 | 3658807 | codebook = ff_svq1_inter_codebooks[level]; | |
170 | 3658807 | mean_vlc = ff_svq1_inter_mean_vlc + 256; | |
171 | 3658807 | multistage_vlc = ff_svq1_inter_multistage_vlc[level]; | |
172 |
2/2✓ Branch 0 taken 13044696 times.
✓ Branch 1 taken 3658807 times.
|
16703503 | for (y = 0; y < h; y++) { |
173 |
2/2✓ Branch 0 taken 89655008 times.
✓ Branch 1 taken 13044696 times.
|
102699704 | for (x = 0; x < w; x++) { |
174 | 89655008 | int v = src[x + y * stride] - ref[x + y * stride]; | |
175 | 89655008 | block[0][x + w * y] = v; | |
176 | 89655008 | best_score += v * v; | |
177 | 89655008 | block_sum[0] += v; | |
178 | } | ||
179 | } | ||
180 | } | ||
181 | |||
182 | 4302522 | best_count = 0; | |
183 | 4302522 | best_score -= (int)((unsigned)block_sum[0] * block_sum[0] >> (level + 3)); | |
184 | 4302522 | best_mean = block_sum[0] + (size >> 1) >> (level + 3); | |
185 | |||
186 |
2/2✓ Branch 0 taken 4095704 times.
✓ Branch 1 taken 206818 times.
|
4302522 | if (level < 4) { |
187 |
2/2✓ Branch 0 taken 24574224 times.
✓ Branch 1 taken 4095704 times.
|
28669928 | for (count = 1; count < 7; count++) { |
188 | 24574224 | int best_vector_score = INT_MAX; | |
189 | 24574224 | int best_vector_sum = -999, best_vector_mean = -999; | |
190 | 24574224 | const int stage = count - 1; | |
191 | const int8_t *vector; | ||
192 | |||
193 |
2/2✓ Branch 0 taken 393187584 times.
✓ Branch 1 taken 24574224 times.
|
417761808 | for (i = 0; i < 16; i++) { |
194 | 393187584 | int sum = codebook_sum[stage * 16 + i]; | |
195 | int sqr, diff, score; | ||
196 | |||
197 | 393187584 | vector = codebook + stage * size * 16 + i * size; | |
198 | 393187584 | sqr = s->svq1encdsp.ssd_int8_vs_int16(vector, block[stage], size); | |
199 | 393187584 | diff = block_sum[stage] - sum; | |
200 | 393187584 | score = sqr - (diff * (int64_t)diff >> (level + 3)); // FIXME: 64 bits slooow | |
201 |
2/2✓ Branch 0 taken 65426753 times.
✓ Branch 1 taken 327760831 times.
|
393187584 | if (score < best_vector_score) { |
202 | 65426753 | int mean = diff + (size >> 1) >> (level + 3); | |
203 | av_assert2(mean > -300 && mean < 300); | ||
204 |
2/2✓ Branch 0 taken 9912177 times.
✓ Branch 1 taken 55514576 times.
|
65426753 | mean = av_clip(mean, intra ? 0 : -256, 255); |
205 | 65426753 | best_vector_score = score; | |
206 | 65426753 | best_vector[stage] = i; | |
207 | 65426753 | best_vector_sum = sum; | |
208 | 65426753 | best_vector_mean = mean; | |
209 | } | ||
210 | } | ||
211 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24574224 times.
|
24574224 | av_assert0(best_vector_mean != -999); |
212 | 24574224 | vector = codebook + stage * size * 16 + best_vector[stage] * size; | |
213 |
2/2✓ Branch 0 taken 420929184 times.
✓ Branch 1 taken 24574224 times.
|
445503408 | for (j = 0; j < size; j++) |
214 | 420929184 | block[stage + 1][j] = block[stage][j] - vector[j]; | |
215 | 24574224 | block_sum[stage + 1] = block_sum[stage] - best_vector_sum; | |
216 | 24574224 | best_vector_score += lambda * | |
217 | 24574224 | (+1 + 4 * count + | |
218 | 24574224 | multistage_vlc[1 + count][1] | |
219 | 24574224 | + mean_vlc[best_vector_mean][1]); | |
220 | |||
221 |
2/2✓ Branch 0 taken 5416629 times.
✓ Branch 1 taken 19157595 times.
|
24574224 | if (best_vector_score < best_score) { |
222 | 5416629 | best_score = best_vector_score; | |
223 | 5416629 | best_count = count; | |
224 | 5416629 | best_mean = best_vector_mean; | |
225 | } | ||
226 | } | ||
227 | } | ||
228 | |||
229 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 4302510 times.
|
4302522 | if (best_mean == -128) |
230 | 12 | best_mean = -127; | |
231 |
2/2✓ Branch 0 taken 6210 times.
✓ Branch 1 taken 4296300 times.
|
4302510 | else if (best_mean == 128) |
232 | 6210 | best_mean = 127; | |
233 | |||
234 | 4302522 | split = 0; | |
235 |
4/4✓ Branch 0 taken 4243230 times.
✓ Branch 1 taken 59292 times.
✓ Branch 2 taken 2116786 times.
✓ Branch 3 taken 2126444 times.
|
4302522 | if (best_score > threshold && level) { |
236 | 2116786 | int score = 0; | |
237 |
2/2✓ Branch 0 taken 1431267 times.
✓ Branch 1 taken 685519 times.
|
2116786 | int offset = level & 1 ? stride * h / 2 : w / 2; |
238 | PutBitContext backup[6]; | ||
239 | |||
240 |
2/2✓ Branch 0 taken 3903357 times.
✓ Branch 1 taken 2116786 times.
|
6020143 | for (i = level - 1; i >= 0; i--) |
241 | 3903357 | backup[i] = s->reorder_pb[i]; | |
242 | 2116786 | score += encode_block(s, src, ref, decoded, stride, level - 1, | |
243 | threshold >> 1, lambda, intra); | ||
244 | 2116786 | score += encode_block(s, src + offset, ref + offset, decoded + offset, | |
245 | stride, level - 1, threshold >> 1, lambda, intra); | ||
246 | 2116786 | score += lambda; | |
247 | |||
248 |
2/2✓ Branch 0 taken 1359243 times.
✓ Branch 1 taken 757543 times.
|
2116786 | if (score < best_score) { |
249 | 1359243 | best_score = score; | |
250 | 1359243 | split = 1; | |
251 | } else { | ||
252 |
2/2✓ Branch 0 taken 1046147 times.
✓ Branch 1 taken 757543 times.
|
1803690 | for (i = level - 1; i >= 0; i--) |
253 | 1046147 | s->reorder_pb[i] = backup[i]; | |
254 | } | ||
255 | } | ||
256 |
2/2✓ Branch 0 taken 2127616 times.
✓ Branch 1 taken 2174906 times.
|
4302522 | if (level > 0) |
257 | 2127616 | put_bits(&s->reorder_pb[level], 1, split); | |
258 | |||
259 |
2/2✓ Branch 0 taken 2943279 times.
✓ Branch 1 taken 1359243 times.
|
4302522 | if (!split) { |
260 | av_assert1(best_mean >= 0 && best_mean < 256 || !intra); | ||
261 | av_assert1(best_mean >= -256 && best_mean < 256); | ||
262 | av_assert1(best_count >= 0 && best_count < 7); | ||
263 | av_assert1(level < 4 || best_count == 0); | ||
264 | |||
265 | /* output the encoding */ | ||
266 | 2943279 | put_bits(&s->reorder_pb[level], | |
267 | 2943279 | multistage_vlc[1 + best_count][1], | |
268 | 2943279 | multistage_vlc[1 + best_count][0]); | |
269 | 2943279 | put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1], | |
270 | 2943279 | mean_vlc[best_mean][0]); | |
271 | |||
272 |
2/2✓ Branch 0 taken 3649044 times.
✓ Branch 1 taken 2943279 times.
|
6592323 | for (i = 0; i < best_count; i++) { |
273 | av_assert2(best_vector[i] >= 0 && best_vector[i] < 16); | ||
274 | 3649044 | put_bits(&s->reorder_pb[level], 4, best_vector[i]); | |
275 | } | ||
276 | |||
277 |
2/2✓ Branch 0 taken 7680728 times.
✓ Branch 1 taken 2943279 times.
|
10624007 | for (y = 0; y < h; y++) |
278 |
2/2✓ Branch 0 taken 36196848 times.
✓ Branch 1 taken 7680728 times.
|
43877576 | for (x = 0; x < w; x++) |
279 | 36196848 | decoded[x + y * stride] = src[x + y * stride] - | |
280 | 36196848 | block[best_count][x + w * y] + | |
281 | best_mean; | ||
282 | } | ||
283 | |||
284 | 4302522 | return best_score; | |
285 | } | ||
286 | |||
287 | 131005 | static void init_block_index(MpegEncContext *const s) | |
288 | { | ||
289 | 131005 | s->block_index[0]= s->b8_stride*(s->mb_y*2 ) + s->mb_x*2; | |
290 | 131005 | s->block_index[1]= s->b8_stride*(s->mb_y*2 ) + 1 + s->mb_x*2; | |
291 | 131005 | s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) + s->mb_x*2; | |
292 | 131005 | s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) + 1 + s->mb_x*2; | |
293 | 131005 | } | |
294 | |||
295 | 600 | static int svq1_encode_plane(SVQ1EncContext *s, int plane, | |
296 | PutBitContext *pb, | ||
297 | const unsigned char *src_plane, | ||
298 | unsigned char *ref_plane, | ||
299 | unsigned char *decoded_plane, | ||
300 | int width, int height, int src_stride, int stride) | ||
301 | { | ||
302 | 600 | MpegEncContext *const s2 = &s->m.c; | |
303 | int x, y; | ||
304 | int i; | ||
305 | int block_width, block_height; | ||
306 | int level; | ||
307 | int threshold[6]; | ||
308 | 600 | uint8_t *src = s->scratchbuf + stride * 32; | |
309 | 600 | const int lambda = (s->quality * s->quality) >> | |
310 | (2 * FF_LAMBDA_SHIFT); | ||
311 | |||
312 | /* figure out the acceptable level thresholds in advance */ | ||
313 | 600 | threshold[5] = QUALITY_THRESHOLD; | |
314 |
2/2✓ Branch 0 taken 3000 times.
✓ Branch 1 taken 600 times.
|
3600 | for (level = 4; level >= 0; level--) |
315 | 3000 | threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER; | |
316 | |||
317 | 600 | block_width = (width + 15) / 16; | |
318 | 600 | block_height = (height + 15) / 16; | |
319 | |||
320 |
2/2✓ Branch 0 taken 540 times.
✓ Branch 1 taken 60 times.
|
600 | if (s->pict_type == AV_PICTURE_TYPE_P) { |
321 | 540 | s2->last_pic.data[0] = ref_plane; | |
322 | 540 | s2->linesize = | |
323 | 540 | s2->last_pic.linesize[0] = | |
324 | 540 | s->m.new_pic->linesize[0] = | |
325 | 540 | s2->cur_pic.linesize[0] = stride; | |
326 | 540 | s2->width = width; | |
327 | 540 | s2->height = height; | |
328 | 540 | s2->mb_width = block_width; | |
329 | 540 | s2->mb_height = block_height; | |
330 | 540 | s2->mb_stride = s2->mb_width + 1; | |
331 | 540 | s2->b8_stride = 2 * s2->mb_width + 1; | |
332 | 540 | s->m.f_code = 1; | |
333 | 540 | s2->pict_type = s->pict_type; | |
334 | 540 | s->m.me.scene_change_score = 0; | |
335 | // s2->out_format = FMT_H263; | ||
336 | // s2->unrestricted_mv = 1; | ||
337 | 540 | s->m.lambda = s->quality; | |
338 | 540 | s2->qscale = s->m.lambda * 139 + | |
339 | 540 | FF_LAMBDA_SCALE * 64 >> | |
340 | FF_LAMBDA_SHIFT + 7; | ||
341 | 540 | s->m.lambda2 = s->m.lambda * s->m.lambda + | |
342 | 540 | FF_LAMBDA_SCALE / 2 >> | |
343 | FF_LAMBDA_SHIFT; | ||
344 | |||
345 | 540 | s->m.mb_type = s->mb_type; | |
346 | |||
347 | // dummies, to avoid segfaults | ||
348 | 540 | s->m.mb_mean = (uint8_t *)s->dummy; | |
349 | 540 | s->m.mb_var = (uint16_t *)s->dummy; | |
350 | 540 | s->m.mc_mb_var = (uint16_t *)s->dummy; | |
351 | 540 | s2->cur_pic.mb_type = s->dummy; | |
352 | |||
353 | 540 | s2->cur_pic.motion_val[0] = s->motion_val8[plane] + 2; | |
354 | 540 | s->m.p_mv_table = s->motion_val16[plane] + | |
355 | 540 | s2->mb_stride + 1; | |
356 | 540 | ff_me_init_pic(&s->m); | |
357 | |||
358 | 540 | s->m.me.dia_size = s->avctx->dia_size; | |
359 | 540 | s2->first_slice_line = 1; | |
360 |
2/2✓ Branch 0 taken 4005 times.
✓ Branch 1 taken 540 times.
|
4545 | for (y = 0; y < block_height; y++) { |
361 | 4005 | s->m.new_pic->data[0] = src - y * 16 * stride; // ugly | |
362 | 4005 | s2->mb_y = y; | |
363 | |||
364 |
4/4✓ Branch 0 taken 60975 times.
✓ Branch 1 taken 3600 times.
✓ Branch 2 taken 60570 times.
✓ Branch 3 taken 405 times.
|
64575 | for (i = 0; i < 16 && i + 16 * y < height; i++) { |
365 | 60570 | memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride], | |
366 | width); | ||
367 |
2/2✓ Branch 0 taken 182700 times.
✓ Branch 1 taken 60570 times.
|
243270 | for (x = width; x < 16 * block_width; x++) |
368 | 182700 | src[i * stride + x] = src[i * stride + x - 1]; | |
369 | } | ||
370 |
3/4✓ Branch 0 taken 3510 times.
✓ Branch 1 taken 4005 times.
✓ Branch 2 taken 3510 times.
✗ Branch 3 not taken.
|
7515 | for (; i < 16 && i + 16 * y < 16 * block_height; i++) |
371 | 3510 | memcpy(&src[i * stride], &src[(i - 1) * stride], | |
372 | 3510 | 16 * block_width); | |
373 | |||
374 |
2/2✓ Branch 0 taken 62055 times.
✓ Branch 1 taken 4005 times.
|
66060 | for (x = 0; x < block_width; x++) { |
375 | 62055 | s2->mb_x = x; | |
376 | 62055 | init_block_index(s2); | |
377 | |||
378 | 62055 | ff_estimate_p_frame_motion(&s->m, x, y); | |
379 | } | ||
380 | 4005 | s2->first_slice_line = 0; | |
381 | } | ||
382 | |||
383 | 540 | ff_fix_long_p_mvs(&s->m, CANDIDATE_MB_TYPE_INTRA); | |
384 | 540 | ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, | |
385 | CANDIDATE_MB_TYPE_INTER, 0); | ||
386 | } | ||
387 | |||
388 | 600 | s2->first_slice_line = 1; | |
389 |
2/2✓ Branch 0 taken 4450 times.
✓ Branch 1 taken 600 times.
|
5050 | for (y = 0; y < block_height; y++) { |
390 |
4/4✓ Branch 0 taken 67750 times.
✓ Branch 1 taken 4000 times.
✓ Branch 2 taken 67300 times.
✓ Branch 3 taken 450 times.
|
71750 | for (i = 0; i < 16 && i + 16 * y < height; i++) { |
391 | 67300 | memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride], | |
392 | width); | ||
393 |
2/2✓ Branch 0 taken 203000 times.
✓ Branch 1 taken 67300 times.
|
270300 | for (x = width; x < 16 * block_width; x++) |
394 | 203000 | src[i * stride + x] = src[i * stride + x - 1]; | |
395 | } | ||
396 |
3/4✓ Branch 0 taken 3900 times.
✓ Branch 1 taken 4450 times.
✓ Branch 2 taken 3900 times.
✗ Branch 3 not taken.
|
8350 | for (; i < 16 && i + 16 * y < 16 * block_height; i++) |
397 | 3900 | memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width); | |
398 | |||
399 | 4450 | s2->mb_y = y; | |
400 |
2/2✓ Branch 0 taken 68950 times.
✓ Branch 1 taken 4450 times.
|
73400 | for (x = 0; x < block_width; x++) { |
401 | uint8_t reorder_buffer[2][6][7 * 32]; | ||
402 | int count[2][6]; | ||
403 | 68950 | int offset = y * 16 * stride + x * 16; | |
404 | 68950 | uint8_t *decoded = decoded_plane + offset; | |
405 | 68950 | const uint8_t *ref = ref_plane + offset; | |
406 | 68950 | int score[4] = { 0, 0, 0, 0 }, best; | |
407 | 68950 | uint8_t *temp = s->scratchbuf; | |
408 | |||
409 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 68950 times.
|
68950 | if (put_bytes_left(pb, 0) < 3000) { // FIXME: check size |
410 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
411 | ✗ | return -1; | |
412 | } | ||
413 | |||
414 | 68950 | s2->mb_x = x; | |
415 | 68950 | init_block_index(s2); | |
416 | |||
417 |
2/2✓ Branch 0 taken 62055 times.
✓ Branch 1 taken 6895 times.
|
68950 | if (s->pict_type == AV_PICTURE_TYPE_I || |
418 |
2/2✓ Branch 0 taken 3450 times.
✓ Branch 1 taken 58605 times.
|
62055 | (s->m.mb_type[x + y * s2->mb_stride] & |
419 | CANDIDATE_MB_TYPE_INTRA)) { | ||
420 |
2/2✓ Branch 0 taken 62070 times.
✓ Branch 1 taken 10345 times.
|
72415 | for (i = 0; i < 6; i++) |
421 | 62070 | init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], | |
422 | 7 * 32); | ||
423 |
2/2✓ Branch 0 taken 3450 times.
✓ Branch 1 taken 6895 times.
|
10345 | if (s->pict_type == AV_PICTURE_TYPE_P) { |
424 | 3450 | put_bits(&s->reorder_pb[5], SVQ1_BLOCK_INTRA_LEN, SVQ1_BLOCK_INTRA_CODE); | |
425 | 3450 | score[0] = SVQ1_BLOCK_INTRA_LEN * lambda; | |
426 | } | ||
427 | 10345 | score[0] += encode_block(s, src + 16 * x, src + 16 * x /* unused */, | |
428 | temp, stride, 5, 64, lambda, 1); | ||
429 |
2/2✓ Branch 0 taken 62070 times.
✓ Branch 1 taken 10345 times.
|
72415 | for (i = 0; i < 6; i++) { |
430 | 62070 | count[0][i] = put_bits_count(&s->reorder_pb[i]); | |
431 | 62070 | flush_put_bits(&s->reorder_pb[i]); | |
432 | } | ||
433 | } else | ||
434 | 58605 | score[0] = INT_MAX; | |
435 | |||
436 | 68950 | best = 0; | |
437 | |||
438 |
2/2✓ Branch 0 taken 62055 times.
✓ Branch 1 taken 6895 times.
|
68950 | if (s->pict_type == AV_PICTURE_TYPE_P) { |
439 | int mx, my, pred_x, pred_y, dxy; | ||
440 | int16_t *motion_ptr; | ||
441 | |||
442 | 62055 | motion_ptr = ff_h263_pred_motion(s2, 0, 0, &pred_x, &pred_y); | |
443 |
2/2✓ Branch 0 taken 58605 times.
✓ Branch 1 taken 3450 times.
|
62055 | if (s->m.mb_type[x + y * s2->mb_stride] & |
444 | CANDIDATE_MB_TYPE_INTER) { | ||
445 |
2/2✓ Branch 0 taken 351630 times.
✓ Branch 1 taken 58605 times.
|
410235 | for (i = 0; i < 6; i++) |
446 | 351630 | init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], | |
447 | 7 * 32); | ||
448 | |||
449 | 58605 | put_bits(&s->reorder_pb[5], SVQ1_BLOCK_INTER_LEN, SVQ1_BLOCK_INTER_CODE); | |
450 | |||
451 | 58605 | mx = motion_ptr[0]; | |
452 | 58605 | my = motion_ptr[1]; | |
453 | av_assert1(mx >= -32 && mx <= 31); | ||
454 | av_assert1(my >= -32 && my <= 31); | ||
455 | av_assert1(pred_x >= -32 && pred_x <= 31); | ||
456 | av_assert1(pred_y >= -32 && pred_y <= 31); | ||
457 | 58605 | ff_h263_encode_motion(&s->reorder_pb[5], mx - pred_x, 1); | |
458 | 58605 | ff_h263_encode_motion(&s->reorder_pb[5], my - pred_y, 1); | |
459 | 58605 | score[1] += lambda * put_bits_count(&s->reorder_pb[5]); | |
460 | |||
461 | 58605 | dxy = (mx & 1) + 2 * (my & 1); | |
462 | |||
463 | 58605 | s2->hdsp.put_pixels_tab[0][dxy](temp + 16*stride, | |
464 | 58605 | ref + (mx >> 1) + | |
465 | 58605 | stride * (my >> 1), | |
466 | stride, 16); | ||
467 | |||
468 | 58605 | score[1] += encode_block(s, src + 16 * x, temp + 16*stride, | |
469 | decoded, stride, 5, 64, lambda, 0); | ||
470 | 58605 | best = score[1] <= score[0]; | |
471 | |||
472 | 58605 | score[2] = s->mecc.sse[0](NULL, src + 16 * x, ref, | |
473 | stride, 16); | ||
474 | 58605 | score[2] += SVQ1_BLOCK_SKIP_LEN * lambda; | |
475 |
6/6✓ Branch 0 taken 119 times.
✓ Branch 1 taken 58486 times.
✓ Branch 2 taken 88 times.
✓ Branch 3 taken 31 times.
✓ Branch 4 taken 83 times.
✓ Branch 5 taken 5 times.
|
58605 | if (score[2] < score[best] && mx == 0 && my == 0) { |
476 | 83 | best = 2; | |
477 | 83 | s2->hdsp.put_pixels_tab[0][0](decoded, ref, stride, 16); | |
478 | 83 | put_bits(pb, SVQ1_BLOCK_SKIP_LEN, SVQ1_BLOCK_SKIP_CODE); | |
479 | } | ||
480 | } | ||
481 | |||
482 |
2/2✓ Branch 0 taken 58522 times.
✓ Branch 1 taken 3533 times.
|
62055 | if (best == 1) { |
483 |
2/2✓ Branch 0 taken 351132 times.
✓ Branch 1 taken 58522 times.
|
409654 | for (i = 0; i < 6; i++) { |
484 | 351132 | count[1][i] = put_bits_count(&s->reorder_pb[i]); | |
485 | 351132 | flush_put_bits(&s->reorder_pb[i]); | |
486 | } | ||
487 | } else { | ||
488 | 3533 | motion_ptr[0] = | |
489 | 3533 | motion_ptr[1] = | |
490 | 3533 | motion_ptr[2] = | |
491 | 3533 | motion_ptr[3] = | |
492 | 3533 | motion_ptr[0 + 2 * s2->b8_stride] = | |
493 | 3533 | motion_ptr[1 + 2 * s2->b8_stride] = | |
494 | 3533 | motion_ptr[2 + 2 * s2->b8_stride] = | |
495 | 3533 | motion_ptr[3 + 2 * s2->b8_stride] = 0; | |
496 | } | ||
497 | } | ||
498 | |||
499 | 68950 | s->rd_total += score[best]; | |
500 | |||
501 |
2/2✓ Branch 0 taken 68867 times.
✓ Branch 1 taken 83 times.
|
68950 | if (best != 2) |
502 |
2/2✓ Branch 0 taken 413202 times.
✓ Branch 1 taken 68867 times.
|
482069 | for (i = 5; i >= 0; i--) |
503 | 413202 | ff_copy_bits(pb, reorder_buffer[best][i], | |
504 | count[best][i]); | ||
505 |
2/2✓ Branch 0 taken 10345 times.
✓ Branch 1 taken 58605 times.
|
68950 | if (best == 0) |
506 | 10345 | s2->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16); | |
507 | } | ||
508 | 4450 | s2->first_slice_line = 0; | |
509 | } | ||
510 | 600 | return 0; | |
511 | } | ||
512 | |||
513 | 4 | static av_cold int svq1_encode_end(AVCodecContext *avctx) | |
514 | { | ||
515 | 4 | SVQ1EncContext *const s = avctx->priv_data; | |
516 | int i; | ||
517 | |||
518 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | if (avctx->frame_num) |
519 | 4 | av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", | |
520 | 4 | s->rd_total / (double)(avctx->width * avctx->height * | |
521 | 4 | avctx->frame_num)); | |
522 | |||
523 | 4 | av_freep(&s->m.me.scratchpad); | |
524 | 4 | av_freep(&s->mb_type); | |
525 | 4 | av_freep(&s->dummy); | |
526 | 4 | av_freep(&s->scratchbuf); | |
527 | |||
528 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 4 times.
|
16 | for (i = 0; i < 3; i++) { |
529 | 12 | av_freep(&s->motion_val8[i]); | |
530 | 12 | av_freep(&s->motion_val16[i]); | |
531 | } | ||
532 | |||
533 | 4 | av_frame_free(&s->current_picture); | |
534 | 4 | av_frame_free(&s->last_picture); | |
535 | 4 | av_frame_free(&s->m.new_pic); | |
536 | |||
537 | 4 | return 0; | |
538 | } | ||
539 | |||
540 | 4 | static av_cold int write_ident(AVCodecContext *avctx, const char *ident) | |
541 | { | ||
542 | 4 | int size = strlen(ident); | |
543 | 4 | avctx->extradata = av_malloc(size + 8); | |
544 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!avctx->extradata) |
545 | ✗ | return AVERROR(ENOMEM); | |
546 | 4 | AV_WB32(avctx->extradata, size + 8); | |
547 | 4 | AV_WL32(avctx->extradata + 4, MKTAG('S', 'V', 'Q', '1')); | |
548 | 4 | memcpy(avctx->extradata + 8, ident, size); | |
549 | 4 | avctx->extradata_size = size + 8; | |
550 | 4 | return 0; | |
551 | } | ||
552 | |||
553 | 4 | static av_cold int svq1_encode_init(AVCodecContext *avctx) | |
554 | { | ||
555 | 4 | SVQ1EncContext *const s = avctx->priv_data; | |
556 | int ret; | ||
557 | |||
558 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
4 | if (avctx->width >= 4096 || avctx->height >= 4096) { |
559 | ✗ | av_log(avctx, AV_LOG_ERROR, "Dimensions too large, maximum is 4095x4095\n"); | |
560 | ✗ | return AVERROR(EINVAL); | |
561 | } | ||
562 | |||
563 | 4 | ff_hpeldsp_init(&s->m.c.hdsp, avctx->flags); | |
564 | 4 | ff_me_cmp_init(&s->mecc, avctx); | |
565 | 4 | ret = ff_me_init(&s->m.me, avctx, &s->mecc, 0); | |
566 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret < 0) |
567 | ✗ | return ret; | |
568 | 4 | ff_mpegvideoencdsp_init(&s->m.mpvencdsp, avctx); | |
569 | |||
570 | 4 | s->current_picture = av_frame_alloc(); | |
571 | 4 | s->last_picture = av_frame_alloc(); | |
572 |
2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
4 | if (!s->current_picture || !s->last_picture) { |
573 | ✗ | return AVERROR(ENOMEM); | |
574 | } | ||
575 | 4 | ret = ff_encode_alloc_frame(avctx, s->current_picture); | |
576 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret < 0) |
577 | ✗ | return ret; | |
578 | 4 | ret = ff_encode_alloc_frame(avctx, s->last_picture); | |
579 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret < 0) |
580 | ✗ | return ret; | |
581 | 4 | s->scratchbuf = av_malloc_array(s->current_picture->linesize[0], 16 * 3); | |
582 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!s->scratchbuf) |
583 | ✗ | return AVERROR(ENOMEM); | |
584 | |||
585 | 4 | s->frame_width = avctx->width; | |
586 | 4 | s->frame_height = avctx->height; | |
587 | |||
588 | 4 | s->y_block_width = (s->frame_width + 15) / 16; | |
589 | 4 | s->y_block_height = (s->frame_height + 15) / 16; | |
590 | |||
591 | 4 | s->avctx = avctx; | |
592 | 4 | s->m.c.avctx = avctx; | |
593 | |||
594 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 4 times.
|
16 | for (size_t plane = 0; plane < FF_ARRAY_ELEMS(s->motion_val16); ++plane) { |
595 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 4 times.
|
12 | const int shift = plane ? 2 : 0; |
596 | 12 | unsigned block_height = ((s->frame_height >> shift) + 15U) / 16; | |
597 | 12 | unsigned block_width = ((s->frame_width >> shift) + 15U) / 16; | |
598 | |||
599 | 12 | s->motion_val8[plane] = av_calloc((2 * block_width + 1) * block_height * 2 + 2, | |
600 | 2 * sizeof(int16_t)); | ||
601 | 12 | s->motion_val16[plane] = av_calloc((block_width + 1) * (block_height + 2) + 1, | |
602 | 2 * sizeof(int16_t)); | ||
603 |
2/4✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
|
12 | if (!s->motion_val8[plane] || !s->motion_val16[plane]) |
604 | ✗ | return AVERROR(ENOMEM); | |
605 | } | ||
606 | |||
607 | 4 | s->m.c.picture_structure = PICT_FRAME; | |
608 | 4 | s->m.me.temp = | |
609 | 8 | s->m.me.scratchpad = av_mallocz((avctx->width + 64) * | |
610 | 4 | 2 * 16 * 2 * sizeof(uint8_t)); | |
611 | 8 | s->mb_type = av_mallocz((s->y_block_width + 1) * | |
612 | 4 | s->y_block_height * sizeof(int16_t)); | |
613 | 8 | s->dummy = av_mallocz((s->y_block_width + 1) * | |
614 | 4 | s->y_block_height * sizeof(int32_t)); | |
615 | 4 | s->m.new_pic = av_frame_alloc(); | |
616 | |||
617 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | if (!s->m.me.scratchpad || |
618 |
3/6✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
|
4 | !s->mb_type || !s->dummy || !s->m.new_pic) |
619 | ✗ | return AVERROR(ENOMEM); | |
620 | |||
621 | 4 | ff_svq1enc_init(&s->svq1encdsp); | |
622 | |||
623 | 4 | s->m.me.mv_penalty = ff_h263_get_mv_penalty(); | |
624 | |||
625 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
4 | return write_ident(avctx, s->avctx->flags & AV_CODEC_FLAG_BITEXACT ? "Lavc" : LIBAVCODEC_IDENT); |
626 | } | ||
627 | |||
628 | 200 | static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt, | |
629 | const AVFrame *pict, int *got_packet) | ||
630 | { | ||
631 | 200 | SVQ1EncContext *const s = avctx->priv_data; | |
632 | PutBitContext pb; | ||
633 | int i, ret; | ||
634 | |||
635 | 200 | ret = ff_alloc_packet(avctx, pkt, s->y_block_width * s->y_block_height * | |
636 | 200 | MAX_MB_BYTES * 3 + FF_INPUT_BUFFER_MIN_SIZE); | |
637 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (ret < 0) |
638 | ✗ | return ret; | |
639 | |||
640 | 200 | FFSWAP(AVFrame*, s->current_picture, s->last_picture); | |
641 | |||
642 |
3/4✓ Branch 0 taken 200 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 180 times.
✓ Branch 3 taken 20 times.
|
200 | if (avctx->gop_size && (avctx->frame_num % avctx->gop_size)) |
643 | 180 | s->pict_type = AV_PICTURE_TYPE_P; | |
644 | else | ||
645 | 20 | s->pict_type = AV_PICTURE_TYPE_I; | |
646 | 200 | s->quality = pict->quality; | |
647 | |||
648 | 200 | ff_side_data_set_encoder_stats(pkt, pict->quality, NULL, 0, s->pict_type); | |
649 | |||
650 | 200 | init_put_bits(&pb, pkt->data, pkt->size); | |
651 | 200 | svq1_write_header(s, &pb, s->pict_type); | |
652 |
2/2✓ Branch 0 taken 600 times.
✓ Branch 1 taken 200 times.
|
800 | for (i = 0; i < 3; i++) { |
653 | 1800 | int ret = svq1_encode_plane(s, i, &pb, | |
654 | 600 | pict->data[i], | |
655 | 600 | s->last_picture->data[i], | |
656 | 600 | s->current_picture->data[i], | |
657 |
2/2✓ Branch 0 taken 400 times.
✓ Branch 1 taken 200 times.
|
600 | s->frame_width / (i ? 4 : 1), |
658 | 600 | s->frame_height / (i ? 4 : 1), | |
659 | 600 | pict->linesize[i], | |
660 |
2/2✓ Branch 0 taken 400 times.
✓ Branch 1 taken 200 times.
|
600 | s->current_picture->linesize[i]); |
661 | 600 | emms_c(); | |
662 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 600 times.
|
600 | if (ret < 0) |
663 | ✗ | return ret; | |
664 | } | ||
665 | |||
666 | // align_put_bits(&pb); | ||
667 |
2/2✓ Branch 1 taken 3154 times.
✓ Branch 2 taken 200 times.
|
3354 | while (put_bits_count(&pb) & 31) |
668 | 3154 | put_bits(&pb, 1, 0); | |
669 | |||
670 | 200 | flush_put_bits(&pb); | |
671 | |||
672 | 200 | pkt->size = put_bytes_output(&pb); | |
673 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 180 times.
|
200 | if (s->pict_type == AV_PICTURE_TYPE_I) |
674 | 20 | pkt->flags |= AV_PKT_FLAG_KEY; | |
675 | 200 | *got_packet = 1; | |
676 | |||
677 | 200 | return 0; | |
678 | } | ||
679 | |||
680 | #define OFFSET(x) offsetof(struct SVQ1EncContext, x) | ||
681 | #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM | ||
682 | static const AVOption options[] = { | ||
683 | { "motion-est", "Motion estimation algorithm", OFFSET(m.me.motion_est), AV_OPT_TYPE_INT, { .i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, VE, .unit = "motion-est"}, | ||
684 | { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" }, | ||
685 | { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" }, | ||
686 | { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, .unit = "motion-est" }, | ||
687 | |||
688 | { NULL }, | ||
689 | }; | ||
690 | |||
691 | static const AVClass svq1enc_class = { | ||
692 | .class_name = "svq1enc", | ||
693 | .item_name = av_default_item_name, | ||
694 | .option = options, | ||
695 | .version = LIBAVUTIL_VERSION_INT, | ||
696 | }; | ||
697 | |||
698 | const FFCodec ff_svq1_encoder = { | ||
699 | .p.name = "svq1", | ||
700 | CODEC_LONG_NAME("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"), | ||
701 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
702 | .p.id = AV_CODEC_ID_SVQ1, | ||
703 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, | ||
704 | .priv_data_size = sizeof(SVQ1EncContext), | ||
705 | .p.priv_class = &svq1enc_class, | ||
706 | .init = svq1_encode_init, | ||
707 | FF_CODEC_ENCODE_CB(svq1_encode_frame), | ||
708 | .close = svq1_encode_end, | ||
709 | CODEC_PIXFMTS(AV_PIX_FMT_YUV410P), | ||
710 | .color_ranges = AVCOL_RANGE_MPEG, | ||
711 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
712 | }; | ||
713 |