FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/snowenc.c
Date: 2025-04-25 22:50:00
Exec Total Coverage
Lines: 1085 1316 82.4%
Functions: 30 33 90.9%
Branches: 633 834 75.9%
Line Branch Exec Source
1 /*
2 * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "libavutil/emms.h"
22 #include "libavutil/intmath.h"
23 #include "libavutil/libm.h"
24 #include "libavutil/log.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/pixdesc.h"
28 #include "avcodec.h"
29 #include "codec_internal.h"
30 #include "encode.h"
31 #include "internal.h" //For AVCodecInternal.recon_frame
32 #include "me_cmp.h"
33 #include "packet_internal.h"
34 #include "qpeldsp.h"
35 #include "snow_dwt.h"
36 #include "snow.h"
37
38 #include "rangecoder.h"
39 #include "mathops.h"
40
41 #include "mpegvideo.h"
42 #include "h263enc.h"
43
44 #define FF_ME_ITER 3
45
46 typedef struct SnowEncContext {
47 SnowContext com;
48 QpelDSPContext qdsp;
49 MpegvideoEncDSPContext mpvencdsp;
50
51 int lambda;
52 int lambda2;
53 int pass1_rc;
54
55 int pred;
56 int memc_only;
57 int no_bitstream;
58 int intra_penalty;
59 int motion_est;
60 int iterative_dia_size;
61 int scenechange_threshold;
62
63 MECmpContext mecc;
64 MPVMainEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MPVEncContext, so this will be removed then (FIXME/XXX)
65 MPVPicture cur_pic, last_pic;
66 #define ME_CACHE_SIZE 1024
67 unsigned me_cache[ME_CACHE_SIZE];
68 unsigned me_cache_generation;
69
70 uint64_t encoding_error[SNOW_MAX_PLANES];
71
72 IDWTELEM obmc_scratchpad[MB_SIZE * MB_SIZE * 12 * 2];
73 } SnowEncContext;
74
75 557820 static void init_ref(MotionEstContext *c, const uint8_t *const src[3],
76 uint8_t *const ref[3], uint8_t *const ref2[3],
77 int x, int y, int ref_index)
78 {
79 557820 SnowContext *s = c->avctx->priv_data;
80 557820 const int offset[3] = {
81 557820 y*c-> stride + x,
82 557820 ((y*c->uvstride + x) >> s->chroma_h_shift),
83 557820 ((y*c->uvstride + x) >> s->chroma_h_shift),
84 };
85
2/2
✓ Branch 0 taken 1673460 times.
✓ Branch 1 taken 557820 times.
 2231280 for (int i = 0; i < 3; i++) {
86 1673460 c->src[0][i] = src [i];
87 1673460 c->ref[0][i] = ref [i] + offset[i];
88 }
89 av_assert2(!ref_index);
90 557820 }
91
92 2810763 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
93 {
94
2/2
✓ Branch 0 taken 2212924 times.
✓ Branch 1 taken 597839 times.
 2810763 if (v) {
95 2212924 const int a = FFABS(v);
96 2212924 const int e = av_log2(a);
97 2212924 const int el = FFMIN(e, 10);
98 int i;
99
100 2212924 put_rac(c, state + 0, 0);
101
102
2/2
✓ Branch 0 taken 5323053 times.
✓ Branch 1 taken 2212924 times.
 7535977 for (i = 0; i < el; i++)
103 5323053 put_rac(c, state + 1 + i, 1); //1..10
104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2212924 times.
 2212924 for(; i < e; i++)
105 ✗ put_rac(c, state + 1 + 9, 1); //1..10
106
1/2
✓ Branch 0 taken 2212924 times.
✗ Branch 1 not taken.
 2212924 put_rac(c, state + 1 + FFMIN(i, 9), 0);
107
108
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2212924 times.
 2212924 for (i = e - 1; i >= el; i--)
109 ✗ put_rac(c, state + 22 + 9, (a >> i) & 1); //22..31
110
2/2
✓ Branch 0 taken 5323053 times.
✓ Branch 1 taken 2212924 times.
 7535977 for(; i >= 0; i--)
111 5323053 put_rac(c, state + 22 + i, (a >> i) & 1); //22..31
112
113
2/2
✓ Branch 0 taken 2212501 times.
✓ Branch 1 taken 423 times.
 2212924 if (is_signed)
114 2212501 put_rac(c, state + 11 + el, v < 0); //11..21
115 } else {
116 597839 put_rac(c, state + 0, 1);
117 }
118 2810763 }
119
120 16307034 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
121 {
122
2/2
✓ Branch 0 taken 6741439 times.
✓ Branch 1 taken 9565595 times.
 16307034 int r = log2 >= 0 ? 1<<log2 : 1;
123
124 av_assert2(v >= 0);
125 av_assert2(log2 >= -4);
126
127
2/2
✓ Branch 0 taken 11893173 times.
✓ Branch 1 taken 16307034 times.
 28200207 while (v >= r) {
128 11893173 put_rac(c, state + 4 + log2, 1);
129 11893173 v -= r;
130 11893173 log2++;
131
2/2
✓ Branch 0 taken 8610057 times.
✓ Branch 1 taken 3283116 times.
 11893173 if (log2 > 0) r += r;
132 }
133 16307034 put_rac(c, state + 4 + log2, 0);
134
135
2/2
✓ Branch 0 taken 16640157 times.
✓ Branch 1 taken 16307034 times.
 32947191 for (int i = log2 - 1; i >= 0; i--)
136 16640157 put_rac(c, state + 31 - i, (v >> i) & 1);
137 16307034 }
138
139 521 static int get_encode_buffer(SnowContext *s, AVFrame *frame)
140 {
141 int ret;
142
143 521 frame->width = s->avctx->width + 2 * EDGE_WIDTH;
144 521 frame->height = s->avctx->height + 2 * EDGE_WIDTH;
145
146 521 ret = ff_encode_alloc_frame(s->avctx, frame);
147
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 521 times.
 521 if (ret < 0)
148 ✗ return ret;
149
2/2
✓ Branch 0 taken 1563 times.
✓ Branch 1 taken 521 times.
 2084 for (int i = 0; frame->data[i]; i++) {
150
2/2
✓ Branch 0 taken 1042 times.
✓ Branch 1 taken 521 times.
 1563 int offset = (EDGE_WIDTH >> (i ? s->chroma_v_shift : 0)) *
151 1563 frame->linesize[i] +
152
2/2
✓ Branch 0 taken 1042 times.
✓ Branch 1 taken 521 times.
 1563 (EDGE_WIDTH >> (i ? s->chroma_h_shift : 0));
153 1563 frame->data[i] += offset;
154 }
155 521 frame->width = s->avctx->width;
156 521 frame->height = s->avctx->height;
157
158 521 return 0;
159 }
160
161 11 static av_cold int encode_init(AVCodecContext *avctx)
162 {
163 11 SnowEncContext *const enc = avctx->priv_data;
164 11 SnowContext *const s = &enc->com;
165 11 MPVEncContext *const mpv = &enc->m.s;
166 int plane_index, ret;
167 int i;
168
169
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 3 times.
 11 if (enc->pred == DWT_97
170
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 && (avctx->flags & AV_CODEC_FLAG_QSCALE)
171
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 && avctx->global_quality == 0){
172 ✗ av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");
173 ✗ return AVERROR(EINVAL);
174 }
175
176 11 s->spatial_decomposition_type = enc->pred; //FIXME add decorrelator type r transform_type
177
178
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 3 times.
 11 s->mv_scale = (avctx->flags & AV_CODEC_FLAG_QPEL) ? 2 : 4;
179 11 s->block_max_depth= (avctx->flags & AV_CODEC_FLAG_4MV ) ? 1 : 0;
180
181
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 11 times.
 44 for(plane_index=0; plane_index<3; plane_index++){
182 33 s->plane[plane_index].diag_mc= 1;
183 33 s->plane[plane_index].htaps= 6;
184 33 s->plane[plane_index].hcoeff[0]= 40;
185 33 s->plane[plane_index].hcoeff[1]= -10;
186 33 s->plane[plane_index].hcoeff[2]= 2;
187 33 s->plane[plane_index].fast_mc= 1;
188 }
189
190 // Must be before ff_snow_common_init()
191 11 ff_hpeldsp_init(&s->hdsp, avctx->flags);
192
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
 11 if ((ret = ff_snow_common_init(avctx)) < 0) {
193 ✗ return ret;
194 }
195
196 #define mcf(dx,dy)\
197 enc->qdsp.put_qpel_pixels_tab [0][dy+dx/4]=\
198 enc->qdsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
199 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\
200 enc->qdsp.put_qpel_pixels_tab [1][dy+dx/4]=\
201 enc->qdsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
202 s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];
203
204 11 mcf( 0, 0)
205 11 mcf( 4, 0)
206 11 mcf( 8, 0)
207 11 mcf(12, 0)
208 11 mcf( 0, 4)
209 11 mcf( 4, 4)
210 11 mcf( 8, 4)
211 11 mcf(12, 4)
212 11 mcf( 0, 8)
213 11 mcf( 4, 8)
214 11 mcf( 8, 8)
215 11 mcf(12, 8)
216 11 mcf( 0,12)
217 11 mcf( 4,12)
218 11 mcf( 8,12)
219 11 mcf(12,12)
220
221 11 ff_me_cmp_init(&enc->mecc, avctx);
222 11 ret = ff_me_init(&mpv->me, avctx, &enc->mecc, 0);
223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (ret < 0)
224 ✗ return ret;
225 11 ff_mpegvideoencdsp_init(&enc->mpvencdsp, avctx);
226
227 11 ff_snow_alloc_blocks(s);
228
229 11 s->version=0;
230
231 11 mpv->c.avctx = avctx;
232 11 enc->m.bit_rate = avctx->bit_rate;
233 11 enc->m.lmin = avctx->mb_lmin;
234 11 enc->m.lmax = avctx->mb_lmax;
235 11 mpv->c.mb_num = (avctx->width * avctx->height + 255) / 256; // For ratecontrol
236
237 11 mpv->me.temp =
238 11 mpv->me.scratchpad = av_calloc(avctx->width + 64, 2*16*2*sizeof(uint8_t));
239
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (!mpv->me.scratchpad)
240 ✗ return AVERROR(ENOMEM);
241
242 11 mpv->me.mv_penalty = ff_h263_get_mv_penalty();
243
244 11 s->max_ref_frames = av_clip(avctx->refs, 1, MAX_REF_FRAMES);
245
246
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if(avctx->flags&AV_CODEC_FLAG_PASS1){
247 ✗ if(!avctx->stats_out)
248 ✗ avctx->stats_out = av_mallocz(256);
249
250 ✗ if (!avctx->stats_out)
251 ✗ return AVERROR(ENOMEM);
252 }
253
2/4
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
 11 if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&AV_CODEC_FLAG_QSCALE)){
254 ✗ ret = ff_rate_control_init(&enc->m);
255 ✗ if(ret < 0)
256 ✗ return ret;
257 }
258 11 enc->pass1_rc = !(avctx->flags & (AV_CODEC_FLAG_QSCALE|AV_CODEC_FLAG_PASS2));
259
260
1/3
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 11 switch(avctx->pix_fmt){
261 11 case AV_PIX_FMT_YUV444P:
262 // case AV_PIX_FMT_YUV422P:
263 case AV_PIX_FMT_YUV420P:
264 // case AV_PIX_FMT_YUV411P:
265 case AV_PIX_FMT_YUV410P:
266 11 s->nb_planes = 3;
267 11 s->colorspace_type= 0;
268 11 break;
269 ✗ case AV_PIX_FMT_GRAY8:
270 ✗ s->nb_planes = 1;
271 ✗ s->colorspace_type = 1;
272 ✗ break;
273 /* case AV_PIX_FMT_RGB32:
274 s->colorspace= 1;
275 break;*/
276 }
277
278 11 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift,
279 &s->chroma_v_shift);
280
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (ret)
281 ✗ return ret;
282
283 11 s->input_picture = av_frame_alloc();
284
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (!s->input_picture)
285 ✗ return AVERROR(ENOMEM);
286
287
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
 11 if ((ret = get_encode_buffer(s, s->input_picture)) < 0)
288 ✗ return ret;
289
290
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 5 times.
 11 if (enc->motion_est == FF_ME_ITER) {
291 6 int size= s->b_width * s->b_height << 2*s->block_max_depth;
292
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
 12 for(i=0; i<s->max_ref_frames; i++){
293 6 s->ref_mvs[i] = av_calloc(size, sizeof(*s->ref_mvs[i]));
294 6 s->ref_scores[i] = av_calloc(size, sizeof(*s->ref_scores[i]));
295
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
 6 if (!s->ref_mvs[i] || !s->ref_scores[i])
296 ✗ return AVERROR(ENOMEM);
297 }
298 }
299
300 11 return 0;
301 }
302
303 //near copy & paste from dsputil, FIXME
304 1673460 static int pix_sum(const uint8_t * pix, int line_size, int w, int h)
305 {
306 int s, i, j;
307
308 1673460 s = 0;
309
2/2
✓ Branch 0 taken 11422080 times.
✓ Branch 1 taken 1673460 times.
 13095540 for (i = 0; i < h; i++) {
310
2/2
✓ Branch 0 taken 98496000 times.
✓ Branch 1 taken 11422080 times.
 109918080 for (j = 0; j < w; j++) {
311 98496000 s += pix[0];
312 98496000 pix ++;
313 }
314 11422080 pix += line_size - w;
315 }
316 1673460 return s;
317 }
318
319 //near copy & paste from dsputil, FIXME
320 557820 static int pix_norm1(const uint8_t * pix, int line_size, int w)
321 {
322 int s, i, j;
323 557820 const uint32_t *sq = ff_square_tab + 256;
324
325 557820 s = 0;
326
2/2
✓ Branch 0 taken 5711040 times.
✓ Branch 1 taken 557820 times.
 6268860 for (i = 0; i < w; i++) {
327
2/2
✓ Branch 0 taken 65664000 times.
✓ Branch 1 taken 5711040 times.
 71375040 for (j = 0; j < w; j ++) {
328 65664000 s += sq[pix[0]];
329 65664000 pix ++;
330 }
331 5711040 pix += line_size - w;
332 }
333 557820 return s;
334 }
335
336 1979900 static inline int get_penalty_factor(int lambda, int lambda2, int type){
337
3/7
✓ Branch 0 taken 1374300 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 323720 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 281880 times.
✗ Branch 6 not taken.
 1979900 switch(type&0xFF){
338 1374300 default:
339 case FF_CMP_SAD:
340 1374300 return lambda>>FF_LAMBDA_SHIFT;
341 ✗ case FF_CMP_DCT:
342 ✗ return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
343 ✗ case FF_CMP_W53:
344 ✗ return (4*lambda)>>(FF_LAMBDA_SHIFT);
345 323720 case FF_CMP_W97:
346 323720 return (2*lambda)>>(FF_LAMBDA_SHIFT);
347 ✗ case FF_CMP_SATD:
348 case FF_CMP_DCT264:
349 ✗ return (2*lambda)>>FF_LAMBDA_SHIFT;
350 281880 case FF_CMP_RD:
351 case FF_CMP_PSNR:
352 case FF_CMP_SSE:
353 case FF_CMP_NSSE:
354 281880 return lambda2>>FF_LAMBDA_SHIFT;
355 ✗ case FF_CMP_BIT:
356 ✗ return 1;
357 }
358 }
359
360 //FIXME copy&paste
361 #define P_LEFT P[1]
362 #define P_TOP P[2]
363 #define P_TOPRIGHT P[3]
364 #define P_MEDIAN P[4]
365 #define P_MV1 P[9]
366 #define FLAG_QPEL 1 //must be 1
367
368 567000 static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
369 {
370 567000 SnowContext *const s = &enc->com;
371 567000 MotionEstContext *const c = &enc->m.s.me;
372 uint8_t p_buffer[1024];
373 uint8_t i_buffer[1024];
374 uint8_t p_state[sizeof(s->block_state)];
375 uint8_t i_state[sizeof(s->block_state)];
376 RangeCoder pc, ic;
377 567000 uint8_t *pbbak= s->c.bytestream;
378 567000 uint8_t *pbbak_start= s->c.bytestream_start;
379 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
380 567000 const int w= s->b_width << s->block_max_depth;
381 567000 const int h= s->b_height << s->block_max_depth;
382 567000 const int rem_depth= s->block_max_depth - level;
383 567000 const int index= (x + y*w) << rem_depth;
384 567000 const int block_w= 1<<(LOG2_MB_SIZE - level);
385 567000 int trx= (x+1)<<rem_depth;
386 567000 int try= (y+1)<<rem_depth;
387
2/2
✓ Branch 0 taken 554112 times.
✓ Branch 1 taken 12888 times.
 567000 const BlockNode *left = x ? &s->block[index-1] : &null_block;
388
2/2
✓ Branch 0 taken 550290 times.
✓ Branch 1 taken 16710 times.
 567000 const BlockNode *top = y ? &s->block[index-w] : &null_block;
389
2/2
✓ Branch 0 taken 554112 times.
✓ Branch 1 taken 12888 times.
 567000 const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
390
2/2
✓ Branch 0 taken 550290 times.
✓ Branch 1 taken 16710 times.
 567000 const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
391
4/4
✓ Branch 0 taken 550290 times.
✓ Branch 1 taken 16710 times.
✓ Branch 2 taken 538046 times.
✓ Branch 3 taken 12244 times.
 567000 const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
392
8/8
✓ Branch 0 taken 550290 times.
✓ Branch 1 taken 16710 times.
✓ Branch 2 taken 538046 times.
✓ Branch 3 taken 12244 times.
✓ Branch 4 taken 263951 times.
✓ Branch 5 taken 274095 times.
✓ Branch 6 taken 74130 times.
✓ Branch 7 taken 189821 times.
 567000 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
393 567000 int pl = left->color[0];
394 567000 int pcb= left->color[1];
395 567000 int pcr= left->color[2];
396 int pmx, pmy;
397 567000 int mx=0, my=0;
398 int l,cr,cb;
399 567000 const int stride= s->current_picture->linesize[0];
400 567000 const int uvstride= s->current_picture->linesize[1];
401 567000 const uint8_t *const current_data[3] = { s->input_picture->data[0] + (x + y* stride)*block_w,
402 567000 s->input_picture->data[1] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift),
403 567000 s->input_picture->data[2] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift)};
404 int P[10][2];
405 int16_t last_mv[3][2];
406 567000 int qpel= !!(s->avctx->flags & AV_CODEC_FLAG_QPEL); //unused
407 567000 const int shift= 1+qpel;
408 567000 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
409 567000 int mx_context= av_log2(2*FFABS(left->mx - top->mx));
410 567000 int my_context= av_log2(2*FFABS(left->my - top->my));
411 567000 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
412 int ref, best_ref, ref_score, ref_mx, ref_my;
413 567000 int range = MAX_MV >> (1 + qpel);
414
415 av_assert0(sizeof(s->block_state) >= 256);
416
2/2
✓ Branch 0 taken 9180 times.
✓ Branch 1 taken 557820 times.
 567000 if(s->keyframe){
417 9180 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
418 9180 return 0;
419 }
420
421 // clip predictors / edge ?
422
423 557820 P_LEFT[0]= left->mx;
424 557820 P_LEFT[1]= left->my;
425 557820 P_TOP [0]= top->mx;
426 557820 P_TOP [1]= top->my;
427 557820 P_TOPRIGHT[0]= tr->mx;
428 557820 P_TOPRIGHT[1]= tr->my;
429
430 557820 last_mv[0][0]= s->block[index].mx;
431 557820 last_mv[0][1]= s->block[index].my;
432 557820 last_mv[1][0]= right->mx;
433 557820 last_mv[1][1]= right->my;
434 557820 last_mv[2][0]= bottom->mx;
435 557820 last_mv[2][1]= bottom->my;
436
437 557820 enc->m.s.c.mb_stride = 2;
438 557820 enc->m.s.c.mb_x =
439 557820 enc->m.s.c.mb_y = 0;
440 557820 c->skip= 0;
441
442 av_assert1(c-> stride == stride);
443 av_assert1(c->uvstride == uvstride);
444
445 557820 c->penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_cmp);
446 557820 c->sub_penalty_factor= get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_sub_cmp);
447 557820 c->mb_penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->mb_cmp);
448 557820 c->current_mv_penalty = c->mv_penalty[enc->m.s.c.f_code=1] + MAX_DMV;
449
450 557820 c->xmin = - x*block_w - 16+3;
451 557820 c->ymin = - y*block_w - 16+3;
452 557820 c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
453 557820 c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
454
455 557820 c->xmin = FFMAX(c->xmin,-range);
456 557820 c->xmax = FFMIN(c->xmax, range);
457 557820 c->ymin = FFMAX(c->ymin,-range);
458 557820 c->ymax = FFMIN(c->ymax, range);
459
460
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 557819 times.
 557820 if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift);
461
2/2
✓ Branch 0 taken 177 times.
✓ Branch 1 taken 557643 times.
 557820 if(P_LEFT[1] > (c->ymax<<shift)) P_LEFT[1] = (c->ymax<<shift);
462
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 557820 times.
 557820 if(P_TOP[0] > (c->xmax<<shift)) P_TOP[0] = (c->xmax<<shift);
463
2/2
✓ Branch 0 taken 1005 times.
✓ Branch 1 taken 556815 times.
 557820 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift);
464
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 557819 times.
 557820 if(P_TOPRIGHT[0] < (c->xmin * (1<<shift))) P_TOPRIGHT[0]= (c->xmin * (1<<shift));
465
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 557819 times.
 557820 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip
466
2/2
✓ Branch 0 taken 1007 times.
✓ Branch 1 taken 556813 times.
 557820 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
467
468 557820 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
469 557820 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
470
471
2/2
✓ Branch 0 taken 16290 times.
✓ Branch 1 taken 541530 times.
 557820 if (!y) {
472 16290 c->pred_x= P_LEFT[0];
473 16290 c->pred_y= P_LEFT[1];
474 } else {
475 541530 c->pred_x = P_MEDIAN[0];
476 541530 c->pred_y = P_MEDIAN[1];
477 }
478
479 557820 score= INT_MAX;
480 557820 best_ref= 0;
481
2/2
✓ Branch 0 taken 557820 times.
✓ Branch 1 taken 557820 times.
 1115640 for(ref=0; ref<s->ref_frames; ref++){
482 557820 init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);
483
484 557820 ref_score = ff_epzs_motion_search(&enc->m.s, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
485 (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
486
487 av_assert2(ref_mx >= c->xmin);
488 av_assert2(ref_mx <= c->xmax);
489 av_assert2(ref_my >= c->ymin);
490 av_assert2(ref_my <= c->ymax);
491
492 557820 ref_score = c->sub_motion_search(&enc->m.s, &ref_mx, &ref_my, ref_score,
493 0, 0, level-LOG2_MB_SIZE+4, block_w);
494 557820 ref_score = ff_get_mb_score(&enc->m.s, ref_mx, ref_my, 0, 0,
495 level-LOG2_MB_SIZE+4, block_w, 0);
496 557820 ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
497
2/2
✓ Branch 0 taken 8640 times.
✓ Branch 1 taken 549180 times.
 557820 if(s->ref_mvs[ref]){
498 8640 s->ref_mvs[ref][index][0]= ref_mx;
499 8640 s->ref_mvs[ref][index][1]= ref_my;
500 8640 s->ref_scores[ref][index]= ref_score;
501 }
502
1/2
✓ Branch 0 taken 557820 times.
✗ Branch 1 not taken.
 557820 if(score > ref_score){
503 557820 score= ref_score;
504 557820 best_ref= ref;
505 557820 mx= ref_mx;
506 557820 my= ref_my;
507 }
508 }
509 //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
510
511 // subpel search
512 557820 base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
513 557820 pc= s->c;
514 557820 pc.bytestream_start=
515 557820 pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
516 557820 memcpy(p_state, s->block_state, sizeof(s->block_state));
517
518
2/2
✓ Branch 0 taken 100440 times.
✓ Branch 1 taken 457380 times.
 557820 if(level!=s->block_max_depth)
519 100440 put_rac(&pc, &p_state[4 + s_context], 1);
520 557820 put_rac(&pc, &p_state[1 + left->type + top->type], 0);
521
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 557820 times.
 557820 if(s->ref_frames > 1)
522 ✗ put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
523 557820 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
524
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 557820 times.
 557820 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
525
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 557820 times.
 557820 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
526 557820 p_len= pc.bytestream - pc.bytestream_start;
527 557820 score += (enc->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
528
529 557820 block_s= block_w*block_w;
530 557820 sum = pix_sum(current_data[0], stride, block_w, block_w);
531 557820 l= (sum + block_s/2)/block_s;
532 557820 iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
533
534
1/2
✓ Branch 0 taken 557820 times.
✗ Branch 1 not taken.
 557820 if (s->nb_planes > 2) {
535 557820 block_s= block_w*block_w>>(s->chroma_h_shift + s->chroma_v_shift);
536 557820 sum = pix_sum(current_data[1], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
537 557820 cb= (sum + block_s/2)/block_s;
538 // iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
539 557820 sum = pix_sum(current_data[2], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
540 557820 cr= (sum + block_s/2)/block_s;
541 // iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
542 }else
543 ✗ cb = cr = 0;
544
545 557820 ic= s->c;
546 557820 ic.bytestream_start=
547 557820 ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
548 557820 memcpy(i_state, s->block_state, sizeof(s->block_state));
549
2/2
✓ Branch 0 taken 100440 times.
✓ Branch 1 taken 457380 times.
 557820 if(level!=s->block_max_depth)
550 100440 put_rac(&ic, &i_state[4 + s_context], 1);
551 557820 put_rac(&ic, &i_state[1 + left->type + top->type], 1);
552 557820 put_symbol(&ic, &i_state[32], l-pl , 1);
553
1/2
✓ Branch 0 taken 557820 times.
✗ Branch 1 not taken.
 557820 if (s->nb_planes > 2) {
554 557820 put_symbol(&ic, &i_state[64], cb-pcb, 1);
555 557820 put_symbol(&ic, &i_state[96], cr-pcr, 1);
556 }
557 557820 i_len= ic.bytestream - ic.bytestream_start;
558 557820 iscore += (enc->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
559
560 av_assert1(iscore < 255*255*256 + enc->lambda2*10);
561 av_assert1(iscore >= 0);
562 av_assert1(l>=0 && l<=255);
563 av_assert1(pl>=0 && pl<=255);
564
565
2/2
✓ Branch 0 taken 156060 times.
✓ Branch 1 taken 401760 times.
 557820 if(level==0){
566 156060 int varc= iscore >> 8;
567 156060 int vard= score >> 8;
568
4/4
✓ Branch 0 taken 34206 times.
✓ Branch 1 taken 121854 times.
✓ Branch 2 taken 12448 times.
✓ Branch 3 taken 21758 times.
 156060 if (vard <= 64 || vard < varc)
569 134302 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
570 else
571 21758 c->scene_change_score += enc->m.s.c.qscale;
572 }
573
574
2/2
✓ Branch 0 taken 100440 times.
✓ Branch 1 taken 457380 times.
 557820 if(level!=s->block_max_depth){
575 100440 put_rac(&s->c, &s->block_state[4 + s_context], 0);
576 100440 score2 = encode_q_branch(enc, level+1, 2*x+0, 2*y+0);
577 100440 score2+= encode_q_branch(enc, level+1, 2*x+1, 2*y+0);
578 100440 score2+= encode_q_branch(enc, level+1, 2*x+0, 2*y+1);
579 100440 score2+= encode_q_branch(enc, level+1, 2*x+1, 2*y+1);
580 100440 score2+= enc->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
581
582
4/4
✓ Branch 0 taken 88596 times.
✓ Branch 1 taken 11844 times.
✓ Branch 2 taken 88580 times.
✓ Branch 3 taken 16 times.
 100440 if(score2 < score && score2 < iscore)
583 88580 return score2;
584 }
585
586
2/2
✓ Branch 0 taken 82082 times.
✓ Branch 1 taken 387158 times.
 469240 if(iscore < score){
587 82082 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
588 82082 memcpy(pbbak, i_buffer, i_len);
589 82082 s->c= ic;
590 82082 s->c.bytestream_start= pbbak_start;
591 82082 s->c.bytestream= pbbak + i_len;
592 82082 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);
593 82082 memcpy(s->block_state, i_state, sizeof(s->block_state));
594 82082 return iscore;
595 }else{
596 387158 memcpy(pbbak, p_buffer, p_len);
597 387158 s->c= pc;
598 387158 s->c.bytestream_start= pbbak_start;
599 387158 s->c.bytestream= pbbak + p_len;
600 387158 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
601 387158 memcpy(s->block_state, p_state, sizeof(s->block_state));
602 387158 return score;
603 }
604 }
605
606 9600 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
607 9600 const int w= s->b_width << s->block_max_depth;
608 9600 const int rem_depth= s->block_max_depth - level;
609 9600 const int index= (x + y*w) << rem_depth;
610 9600 int trx= (x+1)<<rem_depth;
611 9600 BlockNode *b= &s->block[index];
612
2/2
✓ Branch 0 taken 8400 times.
✓ Branch 1 taken 1200 times.
 9600 const BlockNode *left = x ? &s->block[index-1] : &null_block;
613
2/2
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 2400 times.
 9600 const BlockNode *top = y ? &s->block[index-w] : &null_block;
614
4/4
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 2400 times.
✓ Branch 2 taken 6300 times.
✓ Branch 3 taken 900 times.
 9600 const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
615
7/8
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 2400 times.
✓ Branch 2 taken 6300 times.
✓ Branch 3 taken 900 times.
✓ Branch 4 taken 2700 times.
✓ Branch 5 taken 3600 times.
✓ Branch 6 taken 2700 times.
✗ Branch 7 not taken.
 9600 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
616 9600 int pl = left->color[0];
617 9600 int pcb= left->color[1];
618 9600 int pcr= left->color[2];
619 int pmx, pmy;
620 9600 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
621
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9600 times.
 9600 int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;
622
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9600 times.
 9600 int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;
623 9600 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
624
625
2/2
✓ Branch 0 taken 960 times.
✓ Branch 1 taken 8640 times.
 9600 if(s->keyframe){
626 960 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
627 960 return;
628 }
629
630
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8640 times.
 8640 if(level!=s->block_max_depth){
631 ✗ if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
632 ✗ put_rac(&s->c, &s->block_state[4 + s_context], 1);
633 }else{
634 ✗ put_rac(&s->c, &s->block_state[4 + s_context], 0);
635 ✗ encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
636 ✗ encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
637 ✗ encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
638 ✗ encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
639 ✗ return;
640 }
641 }
642
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 8593 times.
 8640 if(b->type & BLOCK_INTRA){
643 47 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
644 47 put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
645 47 put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
646
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
 47 if (s->nb_planes > 2) {
647 47 put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
648 47 put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
649 }
650 47 set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);
651 }else{
652 8593 pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
653 8593 put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
654
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8593 times.
 8593 if(s->ref_frames > 1)
655 ✗ put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);
656 8593 put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
657 8593 put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
658 8593 set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);
659 }
660 }
661
662 54714 static int get_dc(SnowEncContext *enc, int mb_x, int mb_y, int plane_index)
663 {
664 54714 SnowContext *const s = &enc->com;
665 int i, x2, y2;
666 54714 Plane *p= &s->plane[plane_index];
667 54714 const int block_size = MB_SIZE >> s->block_max_depth;
668
2/2
✓ Branch 0 taken 36476 times.
✓ Branch 1 taken 18238 times.
 54714 const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
669
2/2
✓ Branch 0 taken 36476 times.
✓ Branch 1 taken 18238 times.
 54714 const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
670
2/2
✓ Branch 0 taken 36476 times.
✓ Branch 1 taken 18238 times.
 54714 const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
671
2/2
✓ Branch 0 taken 36476 times.
✓ Branch 1 taken 18238 times.
 54714 const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
672 54714 const int ref_stride= s->current_picture->linesize[plane_index];
673 54714 const uint8_t *src = s->input_picture->data[plane_index];
674 54714 IDWTELEM *dst = enc->obmc_scratchpad + plane_index * block_size * block_size * 4; //FIXME change to unsigned
675 54714 const int b_stride = s->b_width << s->block_max_depth;
676 54714 const int w= p->width;
677 54714 const int h= p->height;
678 54714 int index= mb_x + mb_y*b_stride;
679 54714 BlockNode *b= &s->block[index];
680 54714 BlockNode backup= *b;
681 54714 int ab=0;
682 54714 int aa=0;
683
684 av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc stuff above
685
686 54714 b->type|= BLOCK_INTRA;
687 54714 b->color[plane_index]= 0;
688 54714 memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
689
690
2/2
✓ Branch 0 taken 218856 times.
✓ Branch 1 taken 54714 times.
 273570 for(i=0; i<4; i++){
691 218856 int mb_x2= mb_x + (i &1) - 1;
692 218856 int mb_y2= mb_y + (i>>1) - 1;
693 218856 int x= block_w*mb_x2 + block_w/2;
694 218856 int y= block_h*mb_y2 + block_h/2;
695
696 218856 add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,
697 x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
698
699
2/2
✓ Branch 0 taken 2064576 times.
✓ Branch 1 taken 218856 times.
 2283432 for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_h); y2++){
700
2/2
✓ Branch 0 taken 23411232 times.
✓ Branch 1 taken 2064576 times.
 25475808 for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){
701 23411232 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
702 23411232 int obmc_v= obmc[index];
703 int d;
704
2/2
✓ Branch 0 taken 1795776 times.
✓ Branch 1 taken 21615456 times.
 23411232 if(y<0) obmc_v += obmc[index + block_h*obmc_stride];
705
2/2
✓ Branch 0 taken 762816 times.
✓ Branch 1 taken 22648416 times.
 23411232 if(x<0) obmc_v += obmc[index + block_w];
706
2/2
✓ Branch 0 taken 1269024 times.
✓ Branch 1 taken 22142208 times.
 23411232 if(y+block_h>h) obmc_v += obmc[index - block_h*obmc_stride];
707
2/2
✓ Branch 0 taken 600864 times.
✓ Branch 1 taken 22810368 times.
 23411232 if(x+block_w>w) obmc_v += obmc[index - block_w];
708 //FIXME precalculate this or simplify it somehow else
709
710 23411232 d = -dst[index] + (1<<(FRAC_BITS-1));
711 23411232 dst[index] = d;
712 23411232 ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;
713 23411232 aa += obmc_v * obmc_v; //FIXME precalculate this
714 }
715 }
716 }
717 54714 *b= backup;
718
719
1/2
✓ Branch 0 taken 54714 times.
✗ Branch 1 not taken.
 54714 return av_clip_uint8( ROUNDED_DIV((int64_t)ab<<LOG2_OBMC_MAX, aa) ); //FIXME we should not need clipping
720 }
721
722 1263062 static inline int get_block_bits(SnowContext *s, int x, int y, int w){
723 1263062 const int b_stride = s->b_width << s->block_max_depth;
724 1263062 const int b_height = s->b_height<< s->block_max_depth;
725 1263062 int index= x + y*b_stride;
726 1263062 const BlockNode *b = &s->block[index];
727
2/2
✓ Branch 0 taken 1142570 times.
✓ Branch 1 taken 120492 times.
 1263062 const BlockNode *left = x ? &s->block[index-1] : &null_block;
728
2/2
✓ Branch 0 taken 1098940 times.
✓ Branch 1 taken 164122 times.
 1263062 const BlockNode *top = y ? &s->block[index-b_stride] : &null_block;
729
4/4
✓ Branch 0 taken 1098940 times.
✓ Branch 1 taken 164122 times.
✓ Branch 2 taken 988583 times.
✓ Branch 3 taken 110357 times.
 1263062 const BlockNode *tl = y && x ? &s->block[index-b_stride-1] : left;
730
4/4
✓ Branch 0 taken 1098940 times.
✓ Branch 1 taken 164122 times.
✓ Branch 2 taken 959537 times.
✓ Branch 3 taken 139403 times.
 1263062 const BlockNode *tr = y && x+w<b_stride ? &s->block[index-b_stride+w] : tl;
731 int dmx, dmy;
732 // int mx_context= av_log2(2*FFABS(left->mx - top->mx));
733 // int my_context= av_log2(2*FFABS(left->my - top->my));
734
735
6/6
✓ Branch 0 taken 1224517 times.
✓ Branch 1 taken 38545 times.
✓ Branch 2 taken 1194259 times.
✓ Branch 3 taken 30258 times.
✓ Branch 4 taken 119045 times.
✓ Branch 5 taken 1075214 times.
 1263062 if(x<0 || x>=b_stride || y>=b_height)
736 187848 return 0;
737 /*
738 1 0 0
739 01X 1-2 1
740 001XX 3-6 2-3
741 0001XXX 7-14 4-7
742 00001XXXX 15-30 8-15
743 */
744 //FIXME try accurate rate
745 //FIXME intra and inter predictors if surrounding blocks are not the same type
746
2/2
✓ Branch 0 taken 22775 times.
✓ Branch 1 taken 1052439 times.
 1075214 if(b->type & BLOCK_INTRA){
747 22775 return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))
748 22775 + av_log2(2*FFABS(left->color[1] - b->color[1]))
749 22775 + av_log2(2*FFABS(left->color[2] - b->color[2])));
750 }else{
751 1052439 pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);
752 1052439 dmx-= b->mx;
753 1052439 dmy-= b->my;
754 1052439 return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda
755 1052439 + av_log2(2*FFABS(dmy))
756 1052439 + av_log2(2*b->ref));
757 }
758 }
759
760 306440 static int get_block_rd(SnowEncContext *enc, int mb_x, int mb_y,
761 int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2])
762 {
763 306440 SnowContext *const s = &enc->com;
764 306440 Plane *p= &s->plane[plane_index];
765 306440 const int block_size = MB_SIZE >> s->block_max_depth;
766
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 306440 times.
 306440 const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
767
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 306440 times.
 306440 const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
768
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 306440 times.
 306440 const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
769 306440 const int ref_stride= s->current_picture->linesize[plane_index];
770 306440 uint8_t *dst= s->current_picture->data[plane_index];
771 306440 const uint8_t *src = s->input_picture->data[plane_index];
772 306440 IDWTELEM *pred = enc->obmc_scratchpad + plane_index * block_size * block_size * 4;
773 306440 uint8_t *cur = s->scratchbuf;
774 306440 uint8_t *tmp = s->emu_edge_buffer;
775 306440 const int b_stride = s->b_width << s->block_max_depth;
776 306440 const int b_height = s->b_height<< s->block_max_depth;
777 306440 const int w= p->width;
778 306440 const int h= p->height;
779 int distortion;
780 306440 int rate= 0;
781 306440 const int penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, s->avctx->me_cmp);
782 306440 int sx= block_w*mb_x - block_w/2;
783 306440 int sy= block_h*mb_y - block_h/2;
784 306440 int x0= FFMAX(0,-sx);
785 306440 int y0= FFMAX(0,-sy);
786 306440 int x1= FFMIN(block_w*2, w-sx);
787 306440 int y1= FFMIN(block_h*2, h-sy);
788 int i,x,y;
789
790 av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below chckinhg only block_w
791
792 306440 ff_snow_pred_block(s, cur, tmp, ref_stride, sx, sy, block_w*2, block_h*2, &s->block[mb_x + mb_y*b_stride], plane_index, w, h);
793
794
2/2
✓ Branch 0 taken 8675728 times.
✓ Branch 1 taken 306440 times.
 8982168 for(y=y0; y<y1; y++){
795 8675728 const uint8_t *obmc1= obmc_edged[y];
796 8675728 const IDWTELEM *pred1 = pred + y*obmc_stride;
797 8675728 uint8_t *cur1 = cur + y*ref_stride;
798 8675728 uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
799
2/2
✓ Branch 0 taken 262001664 times.
✓ Branch 1 taken 8675728 times.
 270677392 for(x=x0; x<x1; x++){
800 #if FRAC_BITS >= LOG2_OBMC_MAX
801 int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);
802 #else
803 262001664 int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);
804 #endif
805 262001664 v = (v + pred1[x]) >> FRAC_BITS;
806
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 262001664 times.
 262001664 if(v&(~255)) v= ~(v>>31);
807 262001664 dst1[x] = v;
808 }
809 }
810
811 /* copy the regions where obmc[] = (uint8_t)256 */
812
2/2
✓ Branch 0 taken 267895 times.
✓ Branch 1 taken 38545 times.
 306440 if(LOG2_OBMC_MAX == 8
813
2/2
✓ Branch 0 taken 30258 times.
✓ Branch 1 taken 237637 times.
 267895 && (mb_x == 0 || mb_x == b_stride-1)
814
4/4
✓ Branch 0 taken 50641 times.
✓ Branch 1 taken 18162 times.
✓ Branch 2 taken 12962 times.
✓ Branch 3 taken 37679 times.
 68803 && (mb_y == 0 || mb_y == b_height-1)){
815
2/2
✓ Branch 0 taken 17393 times.
✓ Branch 1 taken 13731 times.
 31124 if(mb_x == 0)
816 17393 x1 = block_w;
817 else
818 13731 x0 = block_w;
819
2/2
✓ Branch 0 taken 18162 times.
✓ Branch 1 taken 12962 times.
 31124 if(mb_y == 0)
820 18162 y1 = block_h;
821 else
822 12962 y0 = block_h;
823
2/2
✓ Branch 0 taken 248992 times.
✓ Branch 1 taken 31124 times.
 280116 for(y=y0; y<y1; y++)
824 248992 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
825 }
826
827
1/2
✓ Branch 0 taken 306440 times.
✗ Branch 1 not taken.
 306440 if(block_w==16){
828 /* FIXME rearrange dsputil to fit 32x32 cmp functions */
829 /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */
830 /* FIXME cmps overlap but do not cover the wavelet's whole support.
831 * So improving the score of one block is not strictly guaranteed
832 * to improve the score of the whole frame, thus iterative motion
833 * estimation does not always converge. */
834
1/2
✓ Branch 0 taken 306440 times.
✗ Branch 1 not taken.
 306440 if(s->avctx->me_cmp == FF_CMP_W97)
835 306440 distortion = ff_w97_32_c(&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
836 ✗ else if(s->avctx->me_cmp == FF_CMP_W53)
837 ✗ distortion = ff_w53_32_c(&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
838 else{
839 ✗ distortion = 0;
840 ✗ for(i=0; i<4; i++){
841 ✗ int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
842 ✗ distortion += enc->m.s.me.me_cmp[0](&enc->m.s, src + off, dst + off, ref_stride, 16);
843 }
844 }
845 }else{
846 av_assert2(block_w==8);
847 ✗ distortion = enc->m.s.me.me_cmp[0](&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
848 }
849
850
1/2
✓ Branch 0 taken 306440 times.
✗ Branch 1 not taken.
 306440 if(plane_index==0){
851
2/2
✓ Branch 0 taken 1225760 times.
✓ Branch 1 taken 306440 times.
 1532200 for(i=0; i<4; i++){
852 /* ..RRr
853 * .RXx.
854 * rxx..
855 */
856 1225760 rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
857 }
858
2/2
✓ Branch 0 taken 37302 times.
✓ Branch 1 taken 269138 times.
 306440 if(mb_x == b_stride-2)
859 37302 rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
860 }
861 306440 return distortion + rate*penalty_factor;
862 }
863
864 ✗ static int get_4block_rd(SnowEncContext *enc, int mb_x, int mb_y, int plane_index)
865 {
866 ✗ SnowContext *const s = &enc->com;
867 int i, y2;
868 ✗ Plane *p= &s->plane[plane_index];
869 ✗ const int block_size = MB_SIZE >> s->block_max_depth;
870 ✗ const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
871 ✗ const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
872 ✗ const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
873 ✗ const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
874 ✗ const int ref_stride= s->current_picture->linesize[plane_index];
875 ✗ uint8_t *dst= s->current_picture->data[plane_index];
876 ✗ const uint8_t *src = s->input_picture->data[plane_index];
877 //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst
878 // const has only been removed from zero_dst to suppress a warning
879 static IDWTELEM zero_dst[4096]; //FIXME
880 ✗ const int b_stride = s->b_width << s->block_max_depth;
881 ✗ const int w= p->width;
882 ✗ const int h= p->height;
883 ✗ int distortion= 0;
884 ✗ int rate= 0;
885 ✗ const int penalty_factor= get_penalty_factor(enc->lambda, enc->lambda2, s->avctx->me_cmp);
886
887 av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below
888
889 ✗ for(i=0; i<9; i++){
890 ✗ int mb_x2= mb_x + (i%3) - 1;
891 ✗ int mb_y2= mb_y + (i/3) - 1;
892 ✗ int x= block_w*mb_x2 + block_w/2;
893 ✗ int y= block_h*mb_y2 + block_h/2;
894
895 ✗ add_yblock(s, 0, NULL, zero_dst, dst, obmc,
896 x, y, block_w, block_h, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
897
898 //FIXME find a cleaner/simpler way to skip the outside stuff
899 ✗ for(y2= y; y2<0; y2++)
900 ✗ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
901 ✗ for(y2= h; y2<y+block_h; y2++)
902 ✗ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
903 ✗ if(x<0){
904 ✗ for(y2= y; y2<y+block_h; y2++)
905 ✗ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
906 }
907 ✗ if(x+block_w > w){
908 ✗ for(y2= y; y2<y+block_h; y2++)
909 ✗ memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
910 }
911
912 av_assert1(block_w== 8 || block_w==16);
913 ✗ distortion += enc->m.s.me.me_cmp[block_w==8](&enc->m.s, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
914 }
915
916 ✗ if(plane_index==0){
917 ✗ BlockNode *b= &s->block[mb_x+mb_y*b_stride];
918 ✗ int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);
919
920 /* ..RRRr
921 * .RXXx.
922 * .RXXx.
923 * rxxx.
924 */
925 ✗ if(merged)
926 ✗ rate = get_block_bits(s, mb_x, mb_y, 2);
927 ✗ for(i=merged?4:0; i<9; i++){
928 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
929 ✗ rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
930 }
931 }
932 ✗ return distortion + rate*penalty_factor;
933 }
934
935 21600 static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
936 21600 const int w= b->width;
937 21600 const int h= b->height;
938 int x, y;
939
940 if(1){
941 21600 int run=0;
942 21600 int *runs = s->run_buffer;
943 21600 int run_index=0;
944 int max_index;
945
946
2/2
✓ Branch 0 taken 366600 times.
✓ Branch 1 taken 21600 times.
 388200 for(y=0; y<h; y++){
947
2/2
✓ Branch 0 taken 26496000 times.
✓ Branch 1 taken 366600 times.
 26862600 for(x=0; x<w; x++){
948 26496000 int v, p=0;
949 26496000 int /*ll=0, */l=0, lt=0, t=0, rt=0;
950 26496000 v= src[x + y*stride];
951
952
2/2
✓ Branch 0 taken 25960200 times.
✓ Branch 1 taken 535800 times.
 26496000 if(y){
953 25960200 t= src[x + (y-1)*stride];
954
2/2
✓ Branch 0 taken 25615200 times.
✓ Branch 1 taken 345000 times.
 25960200 if(x){
955 25615200 lt= src[x - 1 + (y-1)*stride];
956 }
957
2/2
✓ Branch 0 taken 25615200 times.
✓ Branch 1 taken 345000 times.
 25960200 if(x + 1 < w){
958 25615200 rt= src[x + 1 + (y-1)*stride];
959 }
960 }
961
2/2
✓ Branch 0 taken 26129400 times.
✓ Branch 1 taken 366600 times.
 26496000 if(x){
962 26129400 l= src[x - 1 + y*stride];
963 /*if(x > 1){
964 if(orientation==1) ll= src[y + (x-2)*stride];
965 else ll= src[x - 2 + y*stride];
966 }*/
967 }
968
2/2
✓ Branch 0 taken 26392500 times.
✓ Branch 1 taken 103500 times.
 26496000 if(parent){
969 26392500 int px= x>>1;
970 26392500 int py= y>>1;
971
4/4
✓ Branch 0 taken 26387100 times.
✓ Branch 1 taken 5400 times.
✓ Branch 2 taken 26380800 times.
✓ Branch 3 taken 6300 times.
 26392500 if(px<b->parent->width && py<b->parent->height)
972 26380800 p= parent[px + py*2*stride];
973 }
974
2/2
✓ Branch 0 taken 2820074 times.
✓ Branch 1 taken 23675926 times.
 26496000 if(!(/*ll|*/l|lt|t|rt|p)){
975
2/2
✓ Branch 0 taken 291706 times.
✓ Branch 1 taken 2528368 times.
 2820074 if(v){
976 291706 runs[run_index++]= run;
977 291706 run=0;
978 }else{
979 2528368 run++;
980 }
981 }
982 }
983 }
984 21600 max_index= run_index;
985 21600 runs[run_index++]= run;
986 21600 run_index=0;
987 21600 run= runs[run_index++];
988
989 21600 put_symbol2(&s->c, b->state[30], max_index, 0);
990
2/2
✓ Branch 0 taken 16975 times.
✓ Branch 1 taken 4625 times.
 21600 if(run_index <= max_index)
991 16975 put_symbol2(&s->c, b->state[1], run, 3);
992
993
2/2
✓ Branch 0 taken 366600 times.
✓ Branch 1 taken 21600 times.
 388200 for(y=0; y<h; y++){
994
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 366600 times.
 366600 if(s->c.bytestream_end - s->c.bytestream < w*40){
995 ✗ av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
996 ✗ return AVERROR(ENOMEM);
997 }
998
2/2
✓ Branch 0 taken 26496000 times.
✓ Branch 1 taken 366600 times.
 26862600 for(x=0; x<w; x++){
999 26496000 int v, p=0;
1000 26496000 int /*ll=0, */l=0, lt=0, t=0, rt=0;
1001 26496000 v= src[x + y*stride];
1002
1003
2/2
✓ Branch 0 taken 25960200 times.
✓ Branch 1 taken 535800 times.
 26496000 if(y){
1004 25960200 t= src[x + (y-1)*stride];
1005
2/2
✓ Branch 0 taken 25615200 times.
✓ Branch 1 taken 345000 times.
 25960200 if(x){
1006 25615200 lt= src[x - 1 + (y-1)*stride];
1007 }
1008
2/2
✓ Branch 0 taken 25615200 times.
✓ Branch 1 taken 345000 times.
 25960200 if(x + 1 < w){
1009 25615200 rt= src[x + 1 + (y-1)*stride];
1010 }
1011 }
1012
2/2
✓ Branch 0 taken 26129400 times.
✓ Branch 1 taken 366600 times.
 26496000 if(x){
1013 26129400 l= src[x - 1 + y*stride];
1014 /*if(x > 1){
1015 if(orientation==1) ll= src[y + (x-2)*stride];
1016 else ll= src[x - 2 + y*stride];
1017 }*/
1018 }
1019
2/2
✓ Branch 0 taken 26392500 times.
✓ Branch 1 taken 103500 times.
 26496000 if(parent){
1020 26392500 int px= x>>1;
1021 26392500 int py= y>>1;
1022
4/4
✓ Branch 0 taken 26387100 times.
✓ Branch 1 taken 5400 times.
✓ Branch 2 taken 26380800 times.
✓ Branch 3 taken 6300 times.
 26392500 if(px<b->parent->width && py<b->parent->height)
1023 26380800 p= parent[px + py*2*stride];
1024 }
1025
2/2
✓ Branch 0 taken 23675926 times.
✓ Branch 1 taken 2820074 times.
 26496000 if(/*ll|*/l|lt|t|rt|p){
1026 23675926 int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
1027
1028 23675926 put_rac(&s->c, &b->state[0][context], !!v);
1029 }else{
1030
2/2
✓ Branch 0 taken 291706 times.
✓ Branch 1 taken 2528368 times.
 2820074 if(!run){
1031 291706 run= runs[run_index++];
1032
1033
2/2
✓ Branch 0 taken 274731 times.
✓ Branch 1 taken 16975 times.
 291706 if(run_index <= max_index)
1034 274731 put_symbol2(&s->c, b->state[1], run, 3);
1035 av_assert2(v);
1036 }else{
1037 2528368 run--;
1038 av_assert2(!v);
1039 }
1040 }
1041
2/2
✓ Branch 0 taken 15993728 times.
✓ Branch 1 taken 10502272 times.
 26496000 if(v){
1042 15993728 int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
1043 15993728 int l2= 2*FFABS(l) + (l<0);
1044 15993728 int t2= 2*FFABS(t) + (t<0);
1045
1046 15993728 put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);
1047 15993728 put_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l2&0xFF] + 3*ff_quant3bA[t2&0xFF]], v<0);
1048 }
1049 }
1050 }
1051 }
1052 21600 return 0;
1053 }
1054
1055 21600 static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
1056 // encode_subband_qtree(s, b, src, parent, stride, orientation);
1057 // encode_subband_z0run(s, b, src, parent, stride, orientation);
1058 21600 return encode_subband_c0run(s, b, src, parent, stride, orientation);
1059 // encode_subband_dzr(s, b, src, parent, stride, orientation);
1060 }
1061
1062 18314 static av_always_inline int check_block_intra(SnowEncContext *enc, int mb_x, int mb_y, int p[3],
1063 uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd)
1064 {
1065 18314 SnowContext *const s = &enc->com;
1066 18314 const int b_stride= s->b_width << s->block_max_depth;
1067 18314 BlockNode *block= &s->block[mb_x + mb_y * b_stride];
1068 18314 BlockNode backup= *block;
1069 int rd;
1070
1071 av_assert2(mb_x>=0 && mb_y>=0);
1072 av_assert2(mb_x<b_stride);
1073
1074 18314 block->color[0] = p[0];
1075 18314 block->color[1] = p[1];
1076 18314 block->color[2] = p[2];
1077 18314 block->type |= BLOCK_INTRA;
1078
1079 18314 rd = get_block_rd(enc, mb_x, mb_y, 0, obmc_edged) + enc->intra_penalty;
1080
1081 //FIXME chroma
1082
2/2
✓ Branch 0 taken 135 times.
✓ Branch 1 taken 18179 times.
 18314 if(rd < *best_rd){
1083 135 *best_rd= rd;
1084 135 return 1;
1085 }else{
1086 18179 *block= backup;
1087 18179 return 0;
1088 }
1089 }
1090
1091 /* special case for int[2] args we discard afterwards,
1092 * fixes compilation problem with gcc 2.95 */
1093 404968 static av_always_inline int check_block_inter(SnowEncContext *enc,
1094 int mb_x, int mb_y, int p0, int p1,
1095 uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd)
1096 {
1097 404968 SnowContext *const s = &enc->com;
1098 404968 const int b_stride = s->b_width << s->block_max_depth;
1099 404968 BlockNode *block = &s->block[mb_x + mb_y * b_stride];
1100 404968 BlockNode backup = *block;
1101 unsigned value;
1102 int rd, index;
1103
1104 av_assert2(mb_x >= 0 && mb_y >= 0);
1105 av_assert2(mb_x < b_stride);
1106
1107 404968 index = (p0 + 31 * p1) & (ME_CACHE_SIZE-1);
1108 404968 value = enc->me_cache_generation + (p0 >> 10) + p1 * (1 << 6) + (block->ref << 12);
1109
2/2
✓ Branch 0 taken 116842 times.
✓ Branch 1 taken 288126 times.
 404968 if (enc->me_cache[index] == value)
1110 116842 return 0;
1111 288126 enc->me_cache[index] = value;
1112
1113 288126 block->mx = p0;
1114 288126 block->my = p1;
1115 288126 block->type &= ~BLOCK_INTRA;
1116
1117 288126 rd = get_block_rd(enc, mb_x, mb_y, 0, obmc_edged);
1118
1119 //FIXME chroma
1120
2/2
✓ Branch 0 taken 63690 times.
✓ Branch 1 taken 224436 times.
 288126 if (rd < *best_rd) {
1121 63690 *best_rd = rd;
1122 63690 return 1;
1123 } else {
1124 224436 *block = backup;
1125 224436 return 0;
1126 }
1127 }
1128
1129 ✗ static av_always_inline int check_4block_inter(SnowEncContext *enc, int mb_x, int mb_y,
1130 int p0, int p1, int ref, int *best_rd)
1131 {
1132 ✗ SnowContext *const s = &enc->com;
1133 ✗ const int b_stride= s->b_width << s->block_max_depth;
1134 ✗ BlockNode *block= &s->block[mb_x + mb_y * b_stride];
1135 BlockNode backup[4];
1136 unsigned value;
1137 int rd, index;
1138
1139 /* We don't initialize backup[] during variable declaration, because
1140 * that fails to compile on MSVC: "cannot convert from 'BlockNode' to
1141 * 'int16_t'". */
1142 ✗ backup[0] = block[0];
1143 ✗ backup[1] = block[1];
1144 ✗ backup[2] = block[b_stride];
1145 ✗ backup[3] = block[b_stride + 1];
1146
1147 av_assert2(mb_x>=0 && mb_y>=0);
1148 av_assert2(mb_x<b_stride);
1149 av_assert2(((mb_x|mb_y)&1) == 0);
1150
1151 ✗ index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);
1152 ✗ value = enc->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);
1153 ✗ if (enc->me_cache[index] == value)
1154 ✗ return 0;
1155 ✗ enc->me_cache[index] = value;
1156
1157 ✗ block->mx= p0;
1158 ✗ block->my= p1;
1159 ✗ block->ref= ref;
1160 ✗ block->type &= ~BLOCK_INTRA;
1161 ✗ block[1]= block[b_stride]= block[b_stride+1]= *block;
1162
1163 ✗ rd = get_4block_rd(enc, mb_x, mb_y, 0);
1164
1165 //FIXME chroma
1166 ✗ if(rd < *best_rd){
1167 ✗ *best_rd= rd;
1168 ✗ return 1;
1169 }else{
1170 ✗ block[0]= backup[0];
1171 ✗ block[1]= backup[1];
1172 ✗ block[b_stride]= backup[2];
1173 ✗ block[b_stride+1]= backup[3];
1174 ✗ return 0;
1175 }
1176 }
1177
1178 270 static void iterative_me(SnowEncContext *enc)
1179 {
1180 270 SnowContext *const s = &enc->com;
1181 int pass, mb_x, mb_y;
1182 270 const int b_width = s->b_width << s->block_max_depth;
1183 270 const int b_height= s->b_height << s->block_max_depth;
1184 270 const int b_stride= b_width;
1185 int color[3];
1186
1187 {
1188 270 RangeCoder r = s->c;
1189 uint8_t state[sizeof(s->block_state)];
1190 270 memcpy(state, s->block_state, sizeof(s->block_state));
1191
2/2
✓ Branch 0 taken 1080 times.
✓ Branch 1 taken 270 times.
 1350 for(mb_y= 0; mb_y<s->b_height; mb_y++)
1192
2/2
✓ Branch 0 taken 8640 times.
✓ Branch 1 taken 1080 times.
 9720 for(mb_x= 0; mb_x<s->b_width; mb_x++)
1193 8640 encode_q_branch(enc, 0, mb_x, mb_y);
1194 270 s->c = r;
1195 270 memcpy(s->block_state, state, sizeof(s->block_state));
1196 }
1197
1198
1/2
✓ Branch 0 taken 933 times.
✗ Branch 1 not taken.
 933 for(pass=0; pass<25; pass++){
1199 933 int change= 0;
1200
1201
2/2
✓ Branch 0 taken 3732 times.
✓ Branch 1 taken 933 times.
 4665 for(mb_y= 0; mb_y<b_height; mb_y++){
1202
2/2
✓ Branch 0 taken 29856 times.
✓ Branch 1 taken 3732 times.
 33588 for(mb_x= 0; mb_x<b_width; mb_x++){
1203 int dia_change, i, j, ref;
1204 29856 int best_rd= INT_MAX, ref_rd;
1205 BlockNode backup, ref_b;
1206 29856 const int index= mb_x + mb_y * b_stride;
1207 29856 BlockNode *block= &s->block[index];
1208
2/2
✓ Branch 0 taken 22392 times.
✓ Branch 1 taken 7464 times.
 29856 BlockNode *tb = mb_y ? &s->block[index-b_stride ] : NULL;
1209
2/2
✓ Branch 0 taken 26124 times.
✓ Branch 1 taken 3732 times.
 29856 BlockNode *lb = mb_x ? &s->block[index -1] : NULL;
1210
2/2
✓ Branch 0 taken 26124 times.
✓ Branch 1 taken 3732 times.
 29856 BlockNode *rb = mb_x+1<b_width ? &s->block[index +1] : NULL;
1211
2/2
✓ Branch 0 taken 22392 times.
✓ Branch 1 taken 7464 times.
 29856 BlockNode *bb = mb_y+1<b_height ? &s->block[index+b_stride ] : NULL;
1212
4/4
✓ Branch 0 taken 26124 times.
✓ Branch 1 taken 3732 times.
✓ Branch 2 taken 19593 times.
✓ Branch 3 taken 6531 times.
 29856 BlockNode *tlb= mb_x && mb_y ? &s->block[index-b_stride-1] : NULL;
1213
4/4
✓ Branch 0 taken 26124 times.
✓ Branch 1 taken 3732 times.
✓ Branch 2 taken 19593 times.
✓ Branch 3 taken 6531 times.
 29856 BlockNode *trb= mb_x+1<b_width && mb_y ? &s->block[index-b_stride+1] : NULL;
1214
4/4
✓ Branch 0 taken 26124 times.
✓ Branch 1 taken 3732 times.
✓ Branch 2 taken 19593 times.
✓ Branch 3 taken 6531 times.
 29856 BlockNode *blb= mb_x && mb_y+1<b_height ? &s->block[index+b_stride-1] : NULL;
1215
4/4
✓ Branch 0 taken 26124 times.
✓ Branch 1 taken 3732 times.
✓ Branch 2 taken 19593 times.
✓ Branch 3 taken 6531 times.
 29856 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->block[index+b_stride+1] : NULL;
1216 29856 const int b_w= (MB_SIZE >> s->block_max_depth);
1217 uint8_t obmc_edged[MB_SIZE * 2][MB_SIZE * 2];
1218
1219
4/4
✓ Branch 0 taken 21216 times.
✓ Branch 1 taken 8640 times.
✓ Branch 2 taken 11618 times.
✓ Branch 3 taken 9598 times.
 29856 if(pass && (block->type & BLOCK_OPT))
1220 11618 continue;
1221 18238 block->type |= BLOCK_OPT;
1222
1223 18238 backup= *block;
1224
1225
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 18217 times.
 18238 if (!enc->me_cache_generation)
1226 21 memset(enc->me_cache, 0, sizeof(enc->me_cache));
1227 18238 enc->me_cache_generation += 1<<22;
1228
1229 //FIXME precalculate
1230 {
1231 int x, y;
1232
2/2
✓ Branch 0 taken 583616 times.
✓ Branch 1 taken 18238 times.
 601854 for (y = 0; y < b_w * 2; y++)
1233 583616 memcpy(obmc_edged[y], ff_obmc_tab[s->block_max_depth] + y * b_w * 2, b_w * 2);
1234
2/2
✓ Branch 0 taken 2241 times.
✓ Branch 1 taken 15997 times.
 18238 if(mb_x==0)
1235
2/2
✓ Branch 0 taken 71712 times.
✓ Branch 1 taken 2241 times.
 73953 for(y=0; y<b_w*2; y++)
1236 71712 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1237
2/2
✓ Branch 0 taken 1763 times.
✓ Branch 1 taken 16475 times.
 18238 if(mb_x==b_stride-1)
1238
2/2
✓ Branch 0 taken 56416 times.
✓ Branch 1 taken 1763 times.
 58179 for(y=0; y<b_w*2; y++)
1239 56416 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1240
2/2
✓ Branch 0 taken 4942 times.
✓ Branch 1 taken 13296 times.
 18238 if(mb_y==0){
1241
2/2
✓ Branch 0 taken 158144 times.
✓ Branch 1 taken 4942 times.
 163086 for(x=0; x<b_w*2; x++)
1242 158144 obmc_edged[0][x] += obmc_edged[b_w-1][x];
1243
2/2
✓ Branch 0 taken 74130 times.
✓ Branch 1 taken 4942 times.
 79072 for(y=1; y<b_w; y++)
1244 74130 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1245 }
1246
2/2
✓ Branch 0 taken 3492 times.
✓ Branch 1 taken 14746 times.
 18238 if(mb_y==b_height-1){
1247
2/2
✓ Branch 0 taken 111744 times.
✓ Branch 1 taken 3492 times.
 115236 for(x=0; x<b_w*2; x++)
1248 111744 obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1249
2/2
✓ Branch 0 taken 52380 times.
✓ Branch 1 taken 3492 times.
 55872 for(y=b_w; y<b_w*2-1; y++)
1250 52380 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1251 }
1252 }
1253
1254 //skip stuff outside the picture
1255
8/8
✓ Branch 0 taken 15997 times.
✓ Branch 1 taken 2241 times.
✓ Branch 2 taken 11647 times.
✓ Branch 3 taken 4350 times.
✓ Branch 4 taken 10354 times.
✓ Branch 5 taken 1293 times.
✓ Branch 6 taken 2743 times.
✓ Branch 7 taken 7611 times.
 18238 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1256 10627 const uint8_t *src = s->input_picture->data[0];
1257 10627 uint8_t *dst= s->current_picture->data[0];
1258 10627 const int stride= s->current_picture->linesize[0];
1259 10627 const int block_w= MB_SIZE >> s->block_max_depth;
1260 10627 const int block_h= MB_SIZE >> s->block_max_depth;
1261 10627 const int sx= block_w*mb_x - block_w/2;
1262 10627 const int sy= block_h*mb_y - block_h/2;
1263 10627 const int w= s->plane[0].width;
1264 10627 const int h= s->plane[0].height;
1265 int y;
1266
1267
2/2
✓ Branch 0 taken 39536 times.
✓ Branch 1 taken 10627 times.
 50163 for(y=sy; y<0; y++)
1268 39536 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1269
2/2
✓ Branch 0 taken 27936 times.
✓ Branch 1 taken 10627 times.
 38563 for(y=h; y<sy+block_h*2; y++)
1270 27936 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1271
2/2
✓ Branch 0 taken 2241 times.
✓ Branch 1 taken 8386 times.
 10627 if(sx<0){
1272
2/2
✓ Branch 0 taken 71712 times.
✓ Branch 1 taken 2241 times.
 73953 for(y=sy; y<sy+block_h*2; y++)
1273 71712 memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1274 }
1275
2/2
✓ Branch 0 taken 1763 times.
✓ Branch 1 taken 8864 times.
 10627 if(sx+block_w*2 > w){
1276
2/2
✓ Branch 0 taken 56416 times.
✓ Branch 1 taken 1763 times.
 58179 for(y=sy; y<sy+block_h*2; y++)
1277 56416 memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1278 }
1279 }
1280
1281 // intra(black) = neighbors' contribution to the current block
1282
2/2
✓ Branch 0 taken 54714 times.
✓ Branch 1 taken 18238 times.
 72952 for(i=0; i < s->nb_planes; i++)
1283 54714 color[i]= get_dc(enc, mb_x, mb_y, i);
1284
1285 // get previous score (cannot be cached due to OBMC)
1286
4/4
✓ Branch 0 taken 9598 times.
✓ Branch 1 taken 8640 times.
✓ Branch 2 taken 76 times.
✓ Branch 3 taken 9522 times.
 18314 if(pass > 0 && (block->type&BLOCK_INTRA)){
1287 76 int color0[3]= {block->color[0], block->color[1], block->color[2]};
1288 76 check_block_intra(enc, mb_x, mb_y, color0, obmc_edged, &best_rd);
1289 }else
1290 18162 check_block_inter(enc, mb_x, mb_y, block->mx, block->my, obmc_edged, &best_rd);
1291
1292 18238 ref_b= *block;
1293 18238 ref_rd= best_rd;
1294
2/2
✓ Branch 0 taken 18238 times.
✓ Branch 1 taken 18238 times.
 36476 for(ref=0; ref < s->ref_frames; ref++){
1295 18238 int16_t (*mvr)[2]= &s->ref_mvs[ref][index];
1296
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18238 times.
 18238 if(s->ref_scores[ref][index] > s->ref_scores[ref_b.ref][index]*3/2) //FIXME tune threshold
1297 ✗ continue;
1298 18238 block->ref= ref;
1299 18238 best_rd= INT_MAX;
1300
1301 18238 check_block_inter(enc, mb_x, mb_y, mvr[0][0], mvr[0][1], obmc_edged, &best_rd);
1302 18238 check_block_inter(enc, mb_x, mb_y, 0, 0, obmc_edged, &best_rd);
1303
2/2
✓ Branch 0 taken 13296 times.
✓ Branch 1 taken 4942 times.
 18238 if(tb)
1304 13296 check_block_inter(enc, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1305
2/2
✓ Branch 0 taken 15997 times.
✓ Branch 1 taken 2241 times.
 18238 if(lb)
1306 15997 check_block_inter(enc, mb_x, mb_y, mvr[-1][0], mvr[-1][1], obmc_edged, &best_rd);
1307
2/2
✓ Branch 0 taken 16475 times.
✓ Branch 1 taken 1763 times.
 18238 if(rb)
1308 16475 check_block_inter(enc, mb_x, mb_y, mvr[1][0], mvr[1][1], obmc_edged, &best_rd);
1309
2/2
✓ Branch 0 taken 14746 times.
✓ Branch 1 taken 3492 times.
 18238 if(bb)
1310 14746 check_block_inter(enc, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1311
1312 /* fullpel ME */
1313 //FIXME avoid subpel interpolation / round to nearest integer
1314 do{
1315 18658 int newx = block->mx;
1316 18658 int newy = block->my;
1317
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18658 times.
 18658 int dia_size = enc->iterative_dia_size ? enc->iterative_dia_size : FFMAX(s->avctx->dia_size, 1);
1318 18658 dia_change=0;
1319
2/2
✓ Branch 0 taken 37316 times.
✓ Branch 1 taken 18658 times.
 55974 for(i=0; i < dia_size; i++){
1320
2/2
✓ Branch 0 taken 18658 times.
✓ Branch 1 taken 37316 times.
 55974 for(j=0; j<i; j++){
1321 18658 dia_change |= check_block_inter(enc, mb_x, mb_y, newx+4*(i-j), newy+(4*j), obmc_edged, &best_rd);
1322 18658 dia_change |= check_block_inter(enc, mb_x, mb_y, newx-4*(i-j), newy-(4*j), obmc_edged, &best_rd);
1323 18658 dia_change |= check_block_inter(enc, mb_x, mb_y, newx-(4*j), newy+4*(i-j), obmc_edged, &best_rd);
1324 18658 dia_change |= check_block_inter(enc, mb_x, mb_y, newx+(4*j), newy-4*(i-j), obmc_edged, &best_rd);
1325 }
1326 }
1327
2/2
✓ Branch 0 taken 420 times.
✓ Branch 1 taken 18238 times.
 18658 }while(dia_change);
1328 /* subpel ME */
1329 do{
1330 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1331 26898 dia_change=0;
1332
2/2
✓ Branch 0 taken 215184 times.
✓ Branch 1 taken 26898 times.
 242082 for(i=0; i<8; i++)
1333 215184 dia_change |= check_block_inter(enc, mb_x, mb_y, block->mx+square[i][0], block->my+square[i][1], obmc_edged, &best_rd);
1334
2/2
✓ Branch 0 taken 8660 times.
✓ Branch 1 taken 18238 times.
 26898 }while(dia_change);
1335 //FIXME or try the standard 2 pass qpel or similar
1336
1337 18238 mvr[0][0]= block->mx;
1338 18238 mvr[0][1]= block->my;
1339
2/2
✓ Branch 0 taken 4362 times.
✓ Branch 1 taken 13876 times.
 18238 if(ref_rd > best_rd){
1340 4362 ref_rd= best_rd;
1341 4362 ref_b= *block;
1342 }
1343 }
1344 18238 best_rd= ref_rd;
1345 18238 *block= ref_b;
1346 18238 check_block_intra(enc, mb_x, mb_y, color, obmc_edged, &best_rd);
1347 //FIXME RD style color selection
1348
2/2
✓ Branch 1 taken 4386 times.
✓ Branch 2 taken 13852 times.
 18238 if(!same_block(block, &backup)){
1349
2/2
✓ Branch 0 taken 3174 times.
✓ Branch 1 taken 1212 times.
 4386 if(tb ) tb ->type &= ~BLOCK_OPT;
1350
2/2
✓ Branch 0 taken 3853 times.
✓ Branch 1 taken 533 times.
 4386 if(lb ) lb ->type &= ~BLOCK_OPT;
1351
2/2
✓ Branch 0 taken 3892 times.
✓ Branch 1 taken 494 times.
 4386 if(rb ) rb ->type &= ~BLOCK_OPT;
1352
2/2
✓ Branch 0 taken 3458 times.
✓ Branch 1 taken 928 times.
 4386 if(bb ) bb ->type &= ~BLOCK_OPT;
1353
2/2
✓ Branch 0 taken 2772 times.
✓ Branch 1 taken 1614 times.
 4386 if(tlb) tlb->type &= ~BLOCK_OPT;
1354
2/2
✓ Branch 0 taken 2822 times.
✓ Branch 1 taken 1564 times.
 4386 if(trb) trb->type &= ~BLOCK_OPT;
1355
2/2
✓ Branch 0 taken 3031 times.
✓ Branch 1 taken 1355 times.
 4386 if(blb) blb->type &= ~BLOCK_OPT;
1356
2/2
✓ Branch 0 taken 3076 times.
✓ Branch 1 taken 1310 times.
 4386 if(brb) brb->type &= ~BLOCK_OPT;
1357 4386 change ++;
1358 }
1359 }
1360 }
1361 933 av_log(s->avctx, AV_LOG_DEBUG, "pass:%d changed:%d\n", pass, change);
1362
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 663 times.
 933 if(!change)
1363 270 break;
1364 }
1365
1366
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 270 times.
 270 if(s->block_max_depth == 1){
1367 ✗ int change= 0;
1368 ✗ for(mb_y= 0; mb_y<b_height; mb_y+=2){
1369 ✗ for(mb_x= 0; mb_x<b_width; mb_x+=2){
1370 int i;
1371 int best_rd, init_rd;
1372 ✗ const int index= mb_x + mb_y * b_stride;
1373 BlockNode *b[4];
1374
1375 ✗ b[0]= &s->block[index];
1376 ✗ b[1]= b[0]+1;
1377 ✗ b[2]= b[0]+b_stride;
1378 ✗ b[3]= b[2]+1;
1379 ✗ if(same_block(b[0], b[1]) &&
1380 ✗ same_block(b[0], b[2]) &&
1381 ✗ same_block(b[0], b[3]))
1382 ✗ continue;
1383
1384 ✗ if (!enc->me_cache_generation)
1385 ✗ memset(enc->me_cache, 0, sizeof(enc->me_cache));
1386 ✗ enc->me_cache_generation += 1<<22;
1387
1388 ✗ init_rd = best_rd = get_4block_rd(enc, mb_x, mb_y, 0);
1389
1390 //FIXME more multiref search?
1391 ✗ check_4block_inter(enc, mb_x, mb_y,
1392 ✗ (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
1393 ✗ (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
1394
1395 ✗ for(i=0; i<4; i++)
1396 ✗ if(!(b[i]->type&BLOCK_INTRA))
1397 ✗ check_4block_inter(enc, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);
1398
1399 ✗ if(init_rd != best_rd)
1400 ✗ change++;
1401 }
1402 }
1403 ✗ av_log(s->avctx, AV_LOG_ERROR, "pass:4mv changed:%d\n", change*4);
1404 }
1405 270 }
1406
1407 510 static void encode_blocks(SnowEncContext *enc, int search)
1408 {
1409 510 SnowContext *const s = &enc->com;
1410 int x, y;
1411 510 int w= s->b_width;
1412 510 int h= s->b_height;
1413
1414
5/6
✓ Branch 0 taken 300 times.
✓ Branch 1 taken 210 times.
✓ Branch 2 taken 270 times.
✓ Branch 3 taken 30 times.
✓ Branch 4 taken 270 times.
✗ Branch 5 not taken.
 510 if (enc->motion_est == FF_ME_ITER && !s->keyframe && search)
1415 270 iterative_me(enc);
1416
1417
2/2
✓ Branch 0 taken 6060 times.
✓ Branch 1 taken 510 times.
 6570 for(y=0; y<h; y++){
1418
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6060 times.
 6060 if(s->c.bytestream_end - s->c.bytestream < w*MB_SIZE*MB_SIZE*3){ //FIXME nicer limit
1419 ✗ av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1420 ✗ return;
1421 }
1422
2/2
✓ Branch 0 taken 166200 times.
✓ Branch 1 taken 6060 times.
 172260 for(x=0; x<w; x++){
1423
3/4
✓ Branch 0 taken 156600 times.
✓ Branch 1 taken 9600 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 156600 times.
 166200 if (enc->motion_est == FF_ME_ITER || !search)
1424 9600 encode_q_branch2(s, 0, x, y);
1425 else
1426 156600 encode_q_branch (enc, 0, x, y);
1427 }
1428 }
1429 }
1430
1431 21600 static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias){
1432 21600 const int w= b->width;
1433 21600 const int h= b->height;
1434 21600 const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1435 21600 const int qmul= ff_qexp[qlog&(QROOT-1)]<<((qlog>>QSHIFT) + ENCODER_EXTRA_BITS);
1436 int x,y, thres1, thres2;
1437
1438
2/2
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 14400 times.
 21600 if(s->qlog == LOSSLESS_QLOG){
1439
2/2
✓ Branch 0 taken 253800 times.
✓ Branch 1 taken 7200 times.
 261000 for(y=0; y<h; y++)
1440
2/2
✓ Branch 0 taken 22809600 times.
✓ Branch 1 taken 253800 times.
 23063400 for(x=0; x<w; x++)
1441 22809600 dst[x + y*stride]= src[x + y*stride];
1442 7200 return;
1443 }
1444
1445
2/2
✓ Branch 0 taken 1440 times.
✓ Branch 1 taken 12960 times.
 14400 bias= bias ? 0 : (3*qmul)>>3;
1446 14400 thres1= ((qmul - bias)>>QEXPSHIFT) - 1;
1447 14400 thres2= 2*thres1;
1448
1449
2/2
✓ Branch 0 taken 12960 times.
✓ Branch 1 taken 1440 times.
 14400 if(!bias){
1450
2/2
✓ Branch 0 taken 101520 times.
✓ Branch 1 taken 12960 times.
 114480 for(y=0; y<h; y++){
1451
2/2
✓ Branch 0 taken 3317760 times.
✓ Branch 1 taken 101520 times.
 3419280 for(x=0; x<w; x++){
1452 3317760 int i= src[x + y*stride];
1453
1454
2/2
✓ Branch 0 taken 550371 times.
✓ Branch 1 taken 2767389 times.
 3317760 if((unsigned)(i+thres1) > thres2){
1455
2/2
✓ Branch 0 taken 275604 times.
✓ Branch 1 taken 274767 times.
 550371 if(i>=0){
1456 275604 i<<= QEXPSHIFT;
1457 275604 i/= qmul; //FIXME optimize
1458 275604 dst[x + y*stride]= i;
1459 }else{
1460 274767 i= -i;
1461 274767 i<<= QEXPSHIFT;
1462 274767 i/= qmul; //FIXME optimize
1463 274767 dst[x + y*stride]= -i;
1464 }
1465 }else
1466 2767389 dst[x + y*stride]= 0;
1467 }
1468 }
1469 }else{
1470
2/2
✓ Branch 0 taken 11280 times.
✓ Branch 1 taken 1440 times.
 12720 for(y=0; y<h; y++){
1471
2/2
✓ Branch 0 taken 368640 times.
✓ Branch 1 taken 11280 times.
 379920 for(x=0; x<w; x++){
1472 368640 int i= src[x + y*stride];
1473
1474
2/2
✓ Branch 0 taken 202458 times.
✓ Branch 1 taken 166182 times.
 368640 if((unsigned)(i+thres1) > thres2){
1475
2/2
✓ Branch 0 taken 101688 times.
✓ Branch 1 taken 100770 times.
 202458 if(i>=0){
1476 101688 i<<= QEXPSHIFT;
1477 101688 i= (i + bias) / qmul; //FIXME optimize
1478 101688 dst[x + y*stride]= i;
1479 }else{
1480 100770 i= -i;
1481 100770 i<<= QEXPSHIFT;
1482 100770 i= (i + bias) / qmul; //FIXME optimize
1483 100770 dst[x + y*stride]= -i;
1484 }
1485 }else
1486 166182 dst[x + y*stride]= 0;
1487 }
1488 }
1489 }
1490 }
1491
1492 21600 static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride){
1493 21600 const int w= b->width;
1494 21600 const int h= b->height;
1495 21600 const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1496 21600 const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1497 21600 const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1498 int x,y;
1499
1500
2/2
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 14400 times.
 21600 if(s->qlog == LOSSLESS_QLOG) return;
1501
1502
2/2
✓ Branch 0 taken 112800 times.
✓ Branch 1 taken 14400 times.
 127200 for(y=0; y<h; y++){
1503
2/2
✓ Branch 0 taken 3686400 times.
✓ Branch 1 taken 112800 times.
 3799200 for(x=0; x<w; x++){
1504 3686400 int i= src[x + y*stride];
1505
2/2
✓ Branch 0 taken 375500 times.
✓ Branch 1 taken 3310900 times.
 3686400 if(i<0){
1506 375500 src[x + y*stride]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
1507
2/2
✓ Branch 0 taken 377275 times.
✓ Branch 1 taken 2933625 times.
 3310900 }else if(i>0){
1508 377275 src[x + y*stride]= (( i*qmul + qadd)>>(QEXPSHIFT));
1509 }
1510 }
1511 }
1512 }
1513
1514 1350 static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1515 1350 const int w= b->width;
1516 1350 const int h= b->height;
1517 int x,y;
1518
1519
2/2
✓ Branch 0 taken 4050 times.
✓ Branch 1 taken 1350 times.
 5400 for(y=h-1; y>=0; y--){
1520
2/2
✓ Branch 0 taken 27450 times.
✓ Branch 1 taken 4050 times.
 31500 for(x=w-1; x>=0; x--){
1521 27450 int i= x + y*stride;
1522
1523
2/2
✓ Branch 0 taken 23400 times.
✓ Branch 1 taken 4050 times.
 27450 if(x){
1524
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23400 times.
 23400 if(use_median){
1525 ✗ if(y && x+1<w) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1526 ✗ else src[i] -= src[i - 1];
1527 }else{
1528
2/2
✓ Branch 0 taken 18900 times.
✓ Branch 1 taken 4500 times.
 23400 if(y) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1529 4500 else src[i] -= src[i - 1];
1530 }
1531 }else{
1532
2/2
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 1350 times.
 4050 if(y) src[i] -= src[i - stride];
1533 }
1534 }
1535 }
1536 1350 }
1537
1538 1350 static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1539 1350 const int w= b->width;
1540 1350 const int h= b->height;
1541 int x,y;
1542
1543
2/2
✓ Branch 0 taken 4050 times.
✓ Branch 1 taken 1350 times.
 5400 for(y=0; y<h; y++){
1544
2/2
✓ Branch 0 taken 27450 times.
✓ Branch 1 taken 4050 times.
 31500 for(x=0; x<w; x++){
1545 27450 int i= x + y*stride;
1546
1547
2/2
✓ Branch 0 taken 23400 times.
✓ Branch 1 taken 4050 times.
 27450 if(x){
1548
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23400 times.
 23400 if(use_median){
1549 ✗ if(y && x+1<w) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1550 ✗ else src[i] += src[i - 1];
1551 }else{
1552
2/2
✓ Branch 0 taken 18900 times.
✓ Branch 1 taken 4500 times.
 23400 if(y) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1553 4500 else src[i] += src[i - 1];
1554 }
1555 }else{
1556
2/2
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 1350 times.
 4050 if(y) src[i] += src[i - stride];
1557 }
1558 }
1559 }
1560 1350 }
1561
1562 47 static void encode_qlogs(SnowContext *s){
1563 int plane_index, level, orientation;
1564
1565
2/2
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 47 times.
 141 for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1566
2/2
✓ Branch 0 taken 470 times.
✓ Branch 1 taken 94 times.
 564 for(level=0; level<s->spatial_decomposition_count; level++){
1567
2/2
✓ Branch 0 taken 1504 times.
✓ Branch 1 taken 470 times.
 1974 for(orientation=level ? 1:0; orientation<4; orientation++){
1568
2/2
✓ Branch 0 taken 470 times.
✓ Branch 1 taken 1034 times.
 1504 if(orientation==2) continue;
1569 1034 put_symbol(&s->c, s->header_state, s->plane[plane_index].band[level][orientation].qlog, 1);
1570 }
1571 }
1572 }
1573 47 }
1574
1575 510 static void encode_header(SnowContext *s){
1576 int plane_index, i;
1577 uint8_t kstate[32];
1578
1579 510 memset(kstate, MID_STATE, sizeof(kstate));
1580
1581 510 put_rac(&s->c, kstate, s->keyframe);
1582
3/4
✓ Branch 0 taken 463 times.
✓ Branch 1 taken 47 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 463 times.
 510 if(s->keyframe || s->always_reset){
1583 47 ff_snow_reset_contexts(s);
1584 47 s->last_spatial_decomposition_type=
1585 47 s->last_qlog=
1586 47 s->last_qbias=
1587 47 s->last_mv_scale=
1588 47 s->last_block_max_depth= 0;
1589
2/2
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 47 times.
 141 for(plane_index=0; plane_index<2; plane_index++){
1590 94 Plane *p= &s->plane[plane_index];
1591 94 p->last_htaps=0;
1592 94 p->last_diag_mc=0;
1593 94 memset(p->last_hcoeff, 0, sizeof(p->last_hcoeff));
1594 }
1595 }
1596
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 463 times.
 510 if(s->keyframe){
1597 47 put_symbol(&s->c, s->header_state, s->version, 0);
1598 47 put_rac(&s->c, s->header_state, s->always_reset);
1599 47 put_symbol(&s->c, s->header_state, s->temporal_decomposition_type, 0);
1600 47 put_symbol(&s->c, s->header_state, s->temporal_decomposition_count, 0);
1601 47 put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1602 47 put_symbol(&s->c, s->header_state, s->colorspace_type, 0);
1603
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
 47 if (s->nb_planes > 2) {
1604 47 put_symbol(&s->c, s->header_state, s->chroma_h_shift, 0);
1605 47 put_symbol(&s->c, s->header_state, s->chroma_v_shift, 0);
1606 }
1607 47 put_rac(&s->c, s->header_state, s->spatial_scalability);
1608 // put_rac(&s->c, s->header_state, s->rate_scalability);
1609 47 put_symbol(&s->c, s->header_state, s->max_ref_frames-1, 0);
1610
1611 47 encode_qlogs(s);
1612 }
1613
1614
2/2
✓ Branch 0 taken 463 times.
✓ Branch 1 taken 47 times.
 510 if(!s->keyframe){
1615 463 int update_mc=0;
1616
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 463 times.
 1389 for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1617 926 Plane *p= &s->plane[plane_index];
1618 926 update_mc |= p->last_htaps != p->htaps;
1619 926 update_mc |= p->last_diag_mc != p->diag_mc;
1620 926 update_mc |= !!memcmp(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1621 }
1622 463 put_rac(&s->c, s->header_state, update_mc);
1623
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 416 times.
 463 if(update_mc){
1624
2/2
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 47 times.
 141 for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1625 94 Plane *p= &s->plane[plane_index];
1626 94 put_rac(&s->c, s->header_state, p->diag_mc);
1627 94 put_symbol(&s->c, s->header_state, p->htaps/2-1, 0);
1628
2/2
✓ Branch 0 taken 282 times.
✓ Branch 1 taken 94 times.
 376 for(i= p->htaps/2; i; i--)
1629 282 put_symbol(&s->c, s->header_state, FFABS(p->hcoeff[i]), 0);
1630 }
1631 }
1632
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 463 times.
 463 if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1633 ✗ put_rac(&s->c, s->header_state, 1);
1634 ✗ put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1635 ✗ encode_qlogs(s);
1636 }else
1637 463 put_rac(&s->c, s->header_state, 0);
1638 }
1639
1640 510 put_symbol(&s->c, s->header_state, s->spatial_decomposition_type - s->last_spatial_decomposition_type, 1);
1641 510 put_symbol(&s->c, s->header_state, s->qlog - s->last_qlog , 1);
1642 510 put_symbol(&s->c, s->header_state, s->mv_scale - s->last_mv_scale, 1);
1643 510 put_symbol(&s->c, s->header_state, s->qbias - s->last_qbias , 1);
1644 510 put_symbol(&s->c, s->header_state, s->block_max_depth - s->last_block_max_depth, 1);
1645
1646 510 }
1647
1648 510 static void update_last_header_values(SnowContext *s){
1649 int plane_index;
1650
1651
2/2
✓ Branch 0 taken 463 times.
✓ Branch 1 taken 47 times.
 510 if(!s->keyframe){
1652
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 463 times.
 1389 for(plane_index=0; plane_index<2; plane_index++){
1653 926 Plane *p= &s->plane[plane_index];
1654 926 p->last_diag_mc= p->diag_mc;
1655 926 p->last_htaps = p->htaps;
1656 926 memcpy(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1657 }
1658 }
1659
1660 510 s->last_spatial_decomposition_type = s->spatial_decomposition_type;
1661 510 s->last_qlog = s->qlog;
1662 510 s->last_qbias = s->qbias;
1663 510 s->last_mv_scale = s->mv_scale;
1664 510 s->last_block_max_depth = s->block_max_depth;
1665 510 s->last_spatial_decomposition_count = s->spatial_decomposition_count;
1666 510 }
1667
1668 360 static int qscale2qlog(int qscale){
1669 360 return lrint(QROOT*log2(qscale / (float)FF_QP2LAMBDA))
1670 360 + 61*QROOT/8; ///< 64 > 60
1671 }
1672
1673 ✗ static int ratecontrol_1pass(SnowEncContext *enc, AVFrame *pict)
1674 {
1675 ✗ SnowContext *const s = &enc->com;
1676 /* Estimate the frame's complexity as a sum of weighted dwt coefficients.
1677 * FIXME we know exact mv bits at this point,
1678 * but ratecontrol isn't set up to include them. */
1679 ✗ uint32_t coef_sum= 0;
1680 int level, orientation, delta_qlog;
1681
1682 ✗ for(level=0; level<s->spatial_decomposition_count; level++){
1683 ✗ for(orientation=level ? 1 : 0; orientation<4; orientation++){
1684 ✗ SubBand *b= &s->plane[0].band[level][orientation];
1685 ✗ IDWTELEM *buf= b->ibuf;
1686 ✗ const int w= b->width;
1687 ✗ const int h= b->height;
1688 ✗ const int stride= b->stride;
1689 ✗ const int qlog= av_clip(2*QROOT + b->qlog, 0, QROOT*16);
1690 ✗ const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1691 ✗ const int qdiv= (1<<16)/qmul;
1692 int x, y;
1693 //FIXME this is ugly
1694 ✗ for(y=0; y<h; y++)
1695 ✗ for(x=0; x<w; x++)
1696 ✗ buf[x+y*stride]= b->buf[x+y*stride];
1697 ✗ if(orientation==0)
1698 ✗ decorrelate(s, b, buf, stride, 1, 0);
1699 ✗ for(y=0; y<h; y++)
1700 ✗ for(x=0; x<w; x++)
1701 ✗ coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1702 }
1703 }
1704
1705 /* ugly, ratecontrol just takes a sqrt again */
1706 ✗ av_assert0(coef_sum < INT_MAX);
1707 ✗ coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1708
1709 ✗ if(pict->pict_type == AV_PICTURE_TYPE_I){
1710 ✗ enc->m.mb_var_sum = coef_sum;
1711 ✗ enc->m.mc_mb_var_sum = 0;
1712 }else{
1713 ✗ enc->m.mc_mb_var_sum = coef_sum;
1714 ✗ enc->m.mb_var_sum = 0;
1715 }
1716
1717 ✗ pict->quality= ff_rate_estimate_qscale(&enc->m, 1);
1718 ✗ if (pict->quality < 0)
1719 ✗ return INT_MIN;
1720 ✗ enc->lambda= pict->quality * 3/2;
1721 ✗ delta_qlog= qscale2qlog(pict->quality) - s->qlog;
1722 ✗ s->qlog+= delta_qlog;
1723 ✗ return delta_qlog;
1724 }
1725
1726 33 static void calculate_visual_weight(SnowContext *s, Plane *p){
1727 33 int width = p->width;
1728 33 int height= p->height;
1729 int level, orientation, x, y;
1730
1731
2/2
✓ Branch 0 taken 165 times.
✓ Branch 1 taken 33 times.
 198 for(level=0; level<s->spatial_decomposition_count; level++){
1732 165 int64_t error=0;
1733
2/2
✓ Branch 0 taken 528 times.
✓ Branch 1 taken 165 times.
 693 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1734 528 SubBand *b= &p->band[level][orientation];
1735 528 IDWTELEM *ibuf= b->ibuf;
1736
1737 528 memset(s->spatial_idwt_buffer, 0, sizeof(*s->spatial_idwt_buffer)*width*height);
1738 528 ibuf[b->width/2 + b->height/2*b->stride]= 256*16;
1739 528 ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, width, height, width, s->spatial_decomposition_type, s->spatial_decomposition_count);
1740
2/2
✓ Branch 0 taken 76800 times.
✓ Branch 1 taken 528 times.
 77328 for(y=0; y<height; y++){
1741
2/2
✓ Branch 0 taken 28385280 times.
✓ Branch 1 taken 76800 times.
 28462080 for(x=0; x<width; x++){
1742 28385280 int64_t d= s->spatial_idwt_buffer[x + y*width]*16;
1743 28385280 error += d*d;
1744 }
1745 }
1746
2/2
✓ Branch 0 taken 165 times.
✓ Branch 1 taken 363 times.
 528 if (orientation == 2)
1747 165 error /= 2;
1748 528 b->qlog= (int)(QROOT * log2(352256.0/sqrt(error)) + 0.5);
1749
2/2
✓ Branch 0 taken 363 times.
✓ Branch 1 taken 165 times.
 528 if (orientation != 1)
1750 363 error = 0;
1751 }
1752 165 p->band[level][1].qlog = p->band[level][2].qlog;
1753 }
1754 33 }
1755
1756 510 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1757 const AVFrame *pict, int *got_packet)
1758 {
1759 510 SnowEncContext *const enc = avctx->priv_data;
1760 510 SnowContext *const s = &enc->com;
1761 510 MPVEncContext *const mpv = &enc->m.s;
1762 510 RangeCoder * const c= &s->c;
1763 510 AVCodecInternal *avci = avctx->internal;
1764 AVFrame *pic;
1765 510 const int width= s->avctx->width;
1766 510 const int height= s->avctx->height;
1767 int level, orientation, plane_index, i, y, ret;
1768 uint8_t rc_header_bak[sizeof(s->header_state)];
1769 uint8_t rc_block_bak[sizeof(s->block_state)];
1770
1771
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 510 times.
 510 if ((ret = ff_alloc_packet(avctx, pkt, s->b_width*s->b_height*MB_SIZE*MB_SIZE*3 + FF_INPUT_BUFFER_MIN_SIZE)) < 0)
1772 ✗ return ret;
1773
1774 510 ff_init_range_encoder(c, pkt->data, pkt->size);
1775 510 ff_build_rac_states(c, (1LL<<32)/20, 256-8);
1776
1777
2/2
✓ Branch 0 taken 1530 times.
✓ Branch 1 taken 510 times.
 2040 for(i=0; i < s->nb_planes; i++){
1778
2/2
✓ Branch 0 taken 1020 times.
✓ Branch 1 taken 510 times.
 1530 int hshift= i ? s->chroma_h_shift : 0;
1779
2/2
✓ Branch 0 taken 1020 times.
✓ Branch 1 taken 510 times.
 1530 int vshift= i ? s->chroma_v_shift : 0;
1780
2/2
✓ Branch 0 taken 193920 times.
✓ Branch 1 taken 1530 times.
 195450 for(y=0; y<AV_CEIL_RSHIFT(height, vshift); y++)
1781 193920 memcpy(&s->input_picture->data[i][y * s->input_picture->linesize[i]],
1782 193920 &pict->data[i][y * pict->linesize[i]],
1783 193920 AV_CEIL_RSHIFT(width, hshift));
1784 1530 enc->mpvencdsp.draw_edges(s->input_picture->data[i], s->input_picture->linesize[i],
1785 1530 AV_CEIL_RSHIFT(width, hshift), AV_CEIL_RSHIFT(height, vshift),
1786 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1787 EDGE_TOP | EDGE_BOTTOM);
1788
1789 }
1790 510 emms_c();
1791 510 pic = s->input_picture;
1792 510 pic->pict_type = pict->pict_type;
1793 510 pic->quality = pict->quality;
1794
1795 510 mpv->c.picture_number = avctx->frame_num;
1796
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
 510 if(avctx->flags&AV_CODEC_FLAG_PASS2){
1797 ✗ mpv->c.pict_type = pic->pict_type = enc->m.rc_context.entry[avctx->frame_num].new_pict_type;
1798 ✗ s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;
1799 ✗ if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) {
1800 ✗ pic->quality = ff_rate_estimate_qscale(&enc->m, 0);
1801 ✗ if (pic->quality < 0)
1802 ✗ return -1;
1803 }
1804 }else{
1805
3/4
✓ Branch 0 taken 510 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 47 times.
✓ Branch 3 taken 463 times.
 510 s->keyframe= avctx->gop_size==0 || avctx->frame_num % avctx->gop_size == 0;
1806
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 463 times.
 510 mpv->c.pict_type = pic->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1807 }
1808
1809
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 510 if (enc->pass1_rc && avctx->frame_num == 0)
1810 ✗ pic->quality = 2*FF_QP2LAMBDA;
1811
2/2
✓ Branch 0 taken 360 times.
✓ Branch 1 taken 150 times.
 510 if (pic->quality) {
1812 360 s->qlog = qscale2qlog(pic->quality);
1813 360 enc->lambda = pic->quality * 3/2;
1814 }
1815
5/6
✓ Branch 0 taken 363 times.
✓ Branch 1 taken 147 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 360 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
 510 if (s->qlog < 0 || (!pic->quality && (avctx->flags & AV_CODEC_FLAG_QSCALE))) {
1816 150 s->qlog= LOSSLESS_QLOG;
1817 150 enc->lambda = 0;
1818 }//else keep previous frame's qlog until after motion estimation
1819
1820
2/2
✓ Branch 0 taken 499 times.
✓ Branch 1 taken 11 times.
 510 if (s->current_picture->data[0]) {
1821 499 int w = s->avctx->width;
1822 499 int h = s->avctx->height;
1823
1824 499 enc->mpvencdsp.draw_edges(s->current_picture->data[0],
1825 499 s->current_picture->linesize[0], w , h ,
1826 EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1827
1/2
✓ Branch 0 taken 499 times.
✗ Branch 1 not taken.
 499 if (s->current_picture->data[2]) {
1828 499 enc->mpvencdsp.draw_edges(s->current_picture->data[1],
1829 499 s->current_picture->linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
1830 499 EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
1831 499 enc->mpvencdsp.draw_edges(s->current_picture->data[2],
1832 499 s->current_picture->linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
1833 499 EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
1834 }
1835 499 emms_c();
1836 }
1837
1838 510 ff_snow_frames_prepare(s);
1839 510 ret = get_encode_buffer(s, s->current_picture);
1840
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
 510 if (ret < 0)
1841 ✗ return ret;
1842
1843 510 mpv->c.cur_pic.ptr = &enc->cur_pic;
1844 510 mpv->c.cur_pic.ptr->f = s->current_picture;
1845 510 mpv->c.cur_pic.ptr->f->pts = pict->pts;
1846
2/2
✓ Branch 0 taken 463 times.
✓ Branch 1 taken 47 times.
 510 if(pic->pict_type == AV_PICTURE_TYPE_P){
1847 463 int block_width = (width +15)>>4;
1848 463 int block_height= (height+15)>>4;
1849 463 int stride= s->current_picture->linesize[0];
1850
1851
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 463 times.
 463 av_assert0(s->current_picture->data[0]);
1852
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 463 times.
 463 av_assert0(s->last_picture[0]->data[0]);
1853
1854 463 mpv->c.avctx = s->avctx;
1855 463 mpv->c.last_pic.ptr = &enc->last_pic;
1856 463 mpv->c.last_pic.ptr->f = s->last_picture[0];
1857 463 mpv-> new_pic = s->input_picture;
1858 463 mpv->c.linesize = stride;
1859 463 mpv->c.uvlinesize = s->current_picture->linesize[1];
1860 463 mpv->c.width = width;
1861 463 mpv->c.height = height;
1862 463 mpv->c.mb_width = block_width;
1863 463 mpv->c.mb_height = block_height;
1864 463 mpv->c.mb_stride = mpv->c.mb_width + 1;
1865 463 mpv->c.b8_stride = 2 * mpv->c.mb_width + 1;
1866 463 mpv->c.f_code = 1;
1867 463 mpv->c.pict_type = pic->pict_type;
1868 463 mpv->me.motion_est = enc->motion_est;
1869 463 mpv->me.dia_size = avctx->dia_size;
1870 463 mpv->c.quarter_sample = (s->avctx->flags & AV_CODEC_FLAG_QPEL)!=0;
1871 463 mpv->c.out_format = FMT_H263;
1872 463 mpv->c.unrestricted_mv = 1;
1873
1874 463 mpv->lambda = enc->lambda;
1875 463 mpv->c.qscale = (mpv->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1876 463 enc->lambda2 = mpv->lambda2 = (mpv->lambda*mpv->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1877
1878 463 mpv->c.qdsp = enc->qdsp; //move
1879 463 mpv->c.hdsp = s->hdsp;
1880 463 ff_me_init_pic(mpv);
1881 463 s->hdsp = mpv->c.hdsp;
1882 }
1883
1884
1/2
✓ Branch 0 taken 510 times.
✗ Branch 1 not taken.
 510 if (enc->pass1_rc) {
1885 ✗ memcpy(rc_header_bak, s->header_state, sizeof(s->header_state));
1886 ✗ memcpy(rc_block_bak, s->block_state, sizeof(s->block_state));
1887 }
1888
1889 510 redo_frame:
1890
1891 510 s->spatial_decomposition_count= 5;
1892
1893 510 while( !(width >>(s->chroma_h_shift + s->spatial_decomposition_count))
1894
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 510 times.
 510 || !(height>>(s->chroma_v_shift + s->spatial_decomposition_count)))
1895 ✗ s->spatial_decomposition_count--;
1896
1897
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
 510 if (s->spatial_decomposition_count <= 0) {
1898 ✗ av_log(avctx, AV_LOG_ERROR, "Resolution too low\n");
1899 ✗ return AVERROR(EINVAL);
1900 }
1901
1902 510 mpv->c.pict_type = pic->pict_type;
1903
2/2
✓ Branch 0 taken 463 times.
✓ Branch 1 taken 47 times.
 510 s->qbias = pic->pict_type == AV_PICTURE_TYPE_P ? 2 : 0;
1904
1905 510 ff_snow_common_init_after_header(avctx);
1906
1907
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 499 times.
 510 if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1908
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 11 times.
 44 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1909 33 calculate_visual_weight(s, &s->plane[plane_index]);
1910 }
1911 }
1912
1913 510 encode_header(s);
1914 510 mpv->misc_bits = 8 * (s->c.bytestream - s->c.bytestream_start);
1915 510 encode_blocks(enc, 1);
1916 510 mpv->mv_bits = 8 * (s->c.bytestream - s->c.bytestream_start) - mpv->misc_bits;
1917
1918
2/2
✓ Branch 0 taken 1530 times.
✓ Branch 1 taken 510 times.
 2040 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1919 1530 Plane *p= &s->plane[plane_index];
1920 1530 int w= p->width;
1921 1530 int h= p->height;
1922 int x, y;
1923 // int bits= put_bits_count(&s->c.pb);
1924
1925
2/2
✓ Branch 0 taken 1350 times.
✓ Branch 1 taken 180 times.
 1530 if (!enc->memc_only) {
1926 //FIXME optimize
1927
1/2
✓ Branch 0 taken 1350 times.
✗ Branch 1 not taken.
 1350 if(pict->data[plane_index]) //FIXME gray hack
1928
2/2
✓ Branch 0 taken 124800 times.
✓ Branch 1 taken 1350 times.
 126150 for(y=0; y<h; y++){
1929
2/2
✓ Branch 0 taken 26496000 times.
✓ Branch 1 taken 124800 times.
 26620800 for(x=0; x<w; x++){
1930 26496000 s->spatial_idwt_buffer[y*w + x]= pict->data[plane_index][y*pict->linesize[plane_index] + x]<<FRAC_BITS;
1931 }
1932 }
1933 1350 predict_plane(s, s->spatial_idwt_buffer, plane_index, 0);
1934
1935
2/2
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 900 times.
 1350 if( plane_index==0
1936
2/2
✓ Branch 0 taken 405 times.
✓ Branch 1 taken 45 times.
 450 && pic->pict_type == AV_PICTURE_TYPE_P
1937
1/2
✓ Branch 0 taken 405 times.
✗ Branch 1 not taken.
 405 && !(avctx->flags&AV_CODEC_FLAG_PASS2)
1938
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 405 times.
 405 && mpv->me.scene_change_score > enc->scenechange_threshold) {
1939 ✗ ff_init_range_encoder(c, pkt->data, pkt->size);
1940 ✗ ff_build_rac_states(c, (1LL<<32)/20, 256-8);
1941 ✗ pic->pict_type= AV_PICTURE_TYPE_I;
1942 ✗ s->keyframe=1;
1943 ✗ s->current_picture->flags |= AV_FRAME_FLAG_KEY;
1944 ✗ goto redo_frame;
1945 }
1946
1947
2/2
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 900 times.
 1350 if(s->qlog == LOSSLESS_QLOG){
1948
2/2
✓ Branch 0 taken 86400 times.
✓ Branch 1 taken 450 times.
 86850 for(y=0; y<h; y++){
1949
2/2
✓ Branch 0 taken 22809600 times.
✓ Branch 1 taken 86400 times.
 22896000 for(x=0; x<w; x++){
1950 22809600 s->spatial_dwt_buffer[y*w + x]= (s->spatial_idwt_buffer[y*w + x] + (1<<(FRAC_BITS-1))-1)>>FRAC_BITS;
1951 }
1952 }
1953 }else{
1954
2/2
✓ Branch 0 taken 38400 times.
✓ Branch 1 taken 900 times.
 39300 for(y=0; y<h; y++){
1955
2/2
✓ Branch 0 taken 3686400 times.
✓ Branch 1 taken 38400 times.
 3724800 for(x=0; x<w; x++){
1956 3686400 s->spatial_dwt_buffer[y*w + x]= s->spatial_idwt_buffer[y*w + x] * (1 << ENCODER_EXTRA_BITS);
1957 }
1958 }
1959 }
1960
1961 1350 ff_spatial_dwt(s->spatial_dwt_buffer, s->temp_dwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
1962
1963
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1350 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1350 if (enc->pass1_rc && plane_index==0) {
1964 ✗ int delta_qlog = ratecontrol_1pass(enc, pic);
1965 ✗ if (delta_qlog <= INT_MIN)
1966 ✗ return -1;
1967 ✗ if(delta_qlog){
1968 //reordering qlog in the bitstream would eliminate this reset
1969 ✗ ff_init_range_encoder(c, pkt->data, pkt->size);
1970 ✗ memcpy(s->header_state, rc_header_bak, sizeof(s->header_state));
1971 ✗ memcpy(s->block_state, rc_block_bak, sizeof(s->block_state));
1972 ✗ encode_header(s);
1973 ✗ encode_blocks(enc, 0);
1974 }
1975 }
1976
1977
2/2
✓ Branch 0 taken 6750 times.
✓ Branch 1 taken 1350 times.
 8100 for(level=0; level<s->spatial_decomposition_count; level++){
1978
2/2
✓ Branch 0 taken 21600 times.
✓ Branch 1 taken 6750 times.
 28350 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1979 21600 SubBand *b= &p->band[level][orientation];
1980
1981 21600 quantize(s, b, b->ibuf, b->buf, b->stride, s->qbias);
1982
2/2
✓ Branch 0 taken 1350 times.
✓ Branch 1 taken 20250 times.
 21600 if(orientation==0)
1983 1350 decorrelate(s, b, b->ibuf, b->stride, pic->pict_type == AV_PICTURE_TYPE_P, 0);
1984
1/2
✓ Branch 0 taken 21600 times.
✗ Branch 1 not taken.
 21600 if (!enc->no_bitstream)
1985
2/2
✓ Branch 0 taken 16200 times.
✓ Branch 1 taken 5400 times.
 21600 encode_subband(s, b, b->ibuf, b->parent ? b->parent->ibuf : NULL, b->stride, orientation);
1986
3/4
✓ Branch 0 taken 16200 times.
✓ Branch 1 taken 5400 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16200 times.
 21600 av_assert0(b->parent==NULL || b->parent->stride == b->stride*2);
1987
2/2
✓ Branch 0 taken 1350 times.
✓ Branch 1 taken 20250 times.
 21600 if(orientation==0)
1988 1350 correlate(s, b, b->ibuf, b->stride, 1, 0);
1989 }
1990 }
1991
1992
2/2
✓ Branch 0 taken 6750 times.
✓ Branch 1 taken 1350 times.
 8100 for(level=0; level<s->spatial_decomposition_count; level++){
1993
2/2
✓ Branch 0 taken 21600 times.
✓ Branch 1 taken 6750 times.
 28350 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1994 21600 SubBand *b= &p->band[level][orientation];
1995
1996 21600 dequantize(s, b, b->ibuf, b->stride);
1997 }
1998 }
1999
2000 1350 ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
2001
2/2
✓ Branch 0 taken 450 times.
✓ Branch 1 taken 900 times.
 1350 if(s->qlog == LOSSLESS_QLOG){
2002
2/2
✓ Branch 0 taken 86400 times.
✓ Branch 1 taken 450 times.
 86850 for(y=0; y<h; y++){
2003
2/2
✓ Branch 0 taken 22809600 times.
✓ Branch 1 taken 86400 times.
 22896000 for(x=0; x<w; x++){
2004 22809600 s->spatial_idwt_buffer[y*w + x] *= 1 << FRAC_BITS;
2005 }
2006 }
2007 }
2008 1350 predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
2009 }else{
2010 //ME/MC only
2011
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 174 times.
 180 if(pic->pict_type == AV_PICTURE_TYPE_I){
2012
2/2
✓ Branch 0 taken 2304 times.
✓ Branch 1 taken 6 times.
 2310 for(y=0; y<h; y++){
2013
2/2
✓ Branch 0 taken 1244160 times.
✓ Branch 1 taken 2304 times.
 1246464 for(x=0; x<w; x++){
2014 1244160 s->current_picture->data[plane_index][y*s->current_picture->linesize[plane_index] + x]=
2015 1244160 pict->data[plane_index][y*pict->linesize[plane_index] + x];
2016 }
2017 }
2018 }else{
2019 174 memset(s->spatial_idwt_buffer, 0, sizeof(IDWTELEM)*w*h);
2020 174 predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
2021 }
2022 }
2023
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1530 times.
 1530 if(s->avctx->flags&AV_CODEC_FLAG_PSNR){
2024 ✗ int64_t error= 0;
2025
2026 ✗ if(pict->data[plane_index]) //FIXME gray hack
2027 ✗ for(y=0; y<h; y++){
2028 ✗ for(x=0; x<w; x++){
2029 ✗ int d= s->current_picture->data[plane_index][y*s->current_picture->linesize[plane_index] + x] - pict->data[plane_index][y*pict->linesize[plane_index] + x];
2030 ✗ error += d*d;
2031 }
2032 }
2033 ✗ s->avctx->error[plane_index] += error;
2034 ✗ enc->encoding_error[plane_index] = error;
2035 }
2036
2037 }
2038 510 emms_c();
2039
2040 510 update_last_header_values(s);
2041
2042 510 av_frame_unref(s->last_picture[s->max_ref_frames - 1]);
2043
2044 510 s->current_picture->pict_type = pic->pict_type;
2045 510 s->current_picture->quality = pic->quality;
2046 510 enc->m.frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start);
2047 510 mpv->p_tex_bits = enc->m.frame_bits - mpv->misc_bits - mpv->mv_bits;
2048 510 enc->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
2049 510 enc->cur_pic.display_picture_number =
2050 510 enc->cur_pic.coded_picture_number = avctx->frame_num;
2051 510 enc->cur_pic.f->quality = pic->quality;
2052
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
 510 if (enc->pass1_rc) {
2053 ✗ ret = ff_rate_estimate_qscale(&enc->m, 0);
2054 ✗ if (ret < 0)
2055 ✗ return ret;
2056 }
2057
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 510 times.
 510 if(avctx->flags&AV_CODEC_FLAG_PASS1)
2058 ✗ ff_write_pass1_stats(&enc->m);
2059 510 enc->m.last_pict_type = mpv->c.pict_type;
2060
2061 510 emms_c();
2062
2063 510 ff_side_data_set_encoder_stats(pkt, s->current_picture->quality,
2064 510 enc->encoding_error,
2065 510 (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? SNOW_MAX_PLANES : 0,
2066 510 s->current_picture->pict_type);
2067
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 450 times.
 510 if (s->avctx->flags & AV_CODEC_FLAG_RECON_FRAME) {
2068 60 av_frame_replace(avci->recon_frame, s->current_picture);
2069 }
2070
2071 510 pkt->size = ff_rac_terminate(c, 0);
2072
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 463 times.
 510 if (s->current_picture->flags & AV_FRAME_FLAG_KEY)
2073 47 pkt->flags |= AV_PKT_FLAG_KEY;
2074 510 *got_packet = 1;
2075
2076 510 return 0;
2077 }
2078
2079 11 static av_cold int encode_end(AVCodecContext *avctx)
2080 {
2081 11 SnowEncContext *const enc = avctx->priv_data;
2082 11 SnowContext *const s = &enc->com;
2083
2084 11 ff_snow_common_end(s);
2085 11 ff_rate_control_uninit(&enc->m.rc_context);
2086 11 av_frame_free(&s->input_picture);
2087
2088
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 11 times.
 99 for (int i = 0; i < MAX_REF_FRAMES; i++) {
2089 88 av_freep(&s->ref_mvs[i]);
2090 88 av_freep(&s->ref_scores[i]);
2091 }
2092
2093 11 enc->m.s.me.temp = NULL;
2094 11 av_freep(&enc->m.s.me.scratchpad);
2095
2096 11 av_freep(&avctx->stats_out);
2097
2098 11 return 0;
2099 }
2100
2101 #define OFFSET(x) offsetof(SnowEncContext, x)
2102 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
2103 static const AVOption options[] = {
2104 {"motion_est", "motion estimation algorithm", OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_ITER, VE, .unit = "motion_est" },
2105 { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, VE, .unit = "motion_est" },
2106 { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, VE, .unit = "motion_est" },
2107 { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, VE, .unit = "motion_est" },
2108 { "iter", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ITER }, 0, 0, VE, .unit = "motion_est" },
2109 { "memc_only", "Only do ME/MC (I frames -> ref, P frame -> ME+MC).", OFFSET(memc_only), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
2110 { "no_bitstream", "Skip final bitstream writeout.", OFFSET(no_bitstream), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
2111 { "intra_penalty", "Penalty for intra blocks in block decission", OFFSET(intra_penalty), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
2112 { "iterative_dia_size", "Dia size for the iterative ME", OFFSET(iterative_dia_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
2113 { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE },
2114 { "pred", "Spatial decomposition type", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, DWT_97, DWT_53, VE, .unit = "pred" },
2115 { "dwt97", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "pred" },
2116 { "dwt53", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "pred" },
2117 { "rc_eq", "Set rate control equation. When computing the expression, besides the standard functions "
2118 "defined in the section 'Expression Evaluation', the following functions are available: "
2119 "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv "
2120 "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.",
2121 OFFSET(m.rc_context.rc_eq), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
2122 { NULL },
2123 };
2124
2125 static const AVClass snowenc_class = {
2126 .class_name = "snow encoder",
2127 .item_name = av_default_item_name,
2128 .option = options,
2129 .version = LIBAVUTIL_VERSION_INT,
2130 };
2131
2132 const FFCodec ff_snow_encoder = {
2133 .p.name = "snow",
2134 CODEC_LONG_NAME("Snow"),
2135 .p.type = AVMEDIA_TYPE_VIDEO,
2136 .p.id = AV_CODEC_ID_SNOW,
2137 .p.capabilities = AV_CODEC_CAP_DR1 |
2138 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE |
2139 AV_CODEC_CAP_ENCODER_RECON_FRAME,
2140 .priv_data_size = sizeof(SnowEncContext),
2141 .init = encode_init,
2142 FF_CODEC_ENCODE_CB(encode_frame),
2143 .close = encode_end,
2144 CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV444P,
2145 AV_PIX_FMT_GRAY8),
2146 .color_ranges = AVCOL_RANGE_MPEG,
2147 .p.priv_class = &snowenc_class,
2148 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
2149 };
2150