FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/snowenc.c
Date: 2023-12-07 21:54:23
Exec Total Coverage
Lines: 1089 1319 82.6%
Functions: 30 33 90.9%
Branches: 636 838 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/opt.h"
26 #include "libavutil/pixdesc.h"
27 #include "avcodec.h"
28 #include "codec_internal.h"
29 #include "encode.h"
30 #include "internal.h" //For AVCodecInternal.recon_frame
31 #include "me_cmp.h"
32 #include "packet_internal.h"
33 #include "qpeldsp.h"
34 #include "snow_dwt.h"
35 #include "snow.h"
36
37 #include "rangecoder.h"
38 #include "mathops.h"
39
40 #include "mpegvideo.h"
41 #include "h263enc.h"
42
43 #define FF_ME_ITER 3
44
45 typedef struct SnowEncContext {
46 SnowContext com;
47 QpelDSPContext qdsp;
48 MpegvideoEncDSPContext mpvencdsp;
49
50 int lambda;
51 int lambda2;
52 int pass1_rc;
53
54 int pred;
55 int memc_only;
56 int no_bitstream;
57 int intra_penalty;
58 int motion_est;
59 int iterative_dia_size;
60 int scenechange_threshold;
61
62 MECmpContext mecc;
63 MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
64 #define ME_CACHE_SIZE 1024
65 unsigned me_cache[ME_CACHE_SIZE];
66 unsigned me_cache_generation;
67
68 uint64_t encoding_error[SNOW_MAX_PLANES];
69 } SnowEncContext;
70
71 557820 static void init_ref(MotionEstContext *c, const uint8_t *const src[3],
72 uint8_t *const ref[3], uint8_t *const ref2[3],
73 int x, int y, int ref_index)
74 {
75 557820 SnowContext *s = c->avctx->priv_data;
76 557820 const int offset[3] = {
77 557820 y*c-> stride + x,
78 557820 ((y*c->uvstride + x) >> s->chroma_h_shift),
79 557820 ((y*c->uvstride + x) >> s->chroma_h_shift),
80 };
81
2/2
✓ Branch 0 taken 1673460 times.
✓ Branch 1 taken 557820 times.
 2231280 for (int i = 0; i < 3; i++) {
82 1673460 c->src[0][i] = src [i];
83 1673460 c->ref[0][i] = ref [i] + offset[i];
84 }
85 av_assert2(!ref_index);
86 557820 }
87
88 2810763 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
89 {
90
2/2
✓ Branch 0 taken 2212924 times.
✓ Branch 1 taken 597839 times.
 2810763 if (v) {
91 2212924 const int a = FFABS(v);
92 2212924 const int e = av_log2(a);
93 2212924 const int el = FFMIN(e, 10);
94 int i;
95
96 2212924 put_rac(c, state + 0, 0);
97
98
2/2
✓ Branch 0 taken 5323053 times.
✓ Branch 1 taken 2212924 times.
 7535977 for (i = 0; i < el; i++)
99 5323053 put_rac(c, state + 1 + i, 1); //1..10
100
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2212924 times.
 2212924 for(; i < e; i++)
101 ✗ put_rac(c, state + 1 + 9, 1); //1..10
102
1/2
✓ Branch 0 taken 2212924 times.
✗ Branch 1 not taken.
 2212924 put_rac(c, state + 1 + FFMIN(i, 9), 0);
103
104
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2212924 times.
 2212924 for (i = e - 1; i >= el; i--)
105 ✗ put_rac(c, state + 22 + 9, (a >> i) & 1); //22..31
106
2/2
✓ Branch 0 taken 5323053 times.
✓ Branch 1 taken 2212924 times.
 7535977 for(; i >= 0; i--)
107 5323053 put_rac(c, state + 22 + i, (a >> i) & 1); //22..31
108
109
2/2
✓ Branch 0 taken 2212501 times.
✓ Branch 1 taken 423 times.
 2212924 if (is_signed)
110 2212501 put_rac(c, state + 11 + el, v < 0); //11..21
111 } else {
112 597839 put_rac(c, state + 0, 1);
113 }
114 2810763 }
115
116 16307034 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
117 {
118
2/2
✓ Branch 0 taken 6741439 times.
✓ Branch 1 taken 9565595 times.
 16307034 int r = log2 >= 0 ? 1<<log2 : 1;
119
120 av_assert2(v >= 0);
121 av_assert2(log2 >= -4);
122
123
2/2
✓ Branch 0 taken 11893173 times.
✓ Branch 1 taken 16307034 times.
 28200207 while (v >= r) {
124 11893173 put_rac(c, state + 4 + log2, 1);
125 11893173 v -= r;
126 11893173 log2++;
127
2/2
✓ Branch 0 taken 8610057 times.
✓ Branch 1 taken 3283116 times.
 11893173 if (log2 > 0) r += r;
128 }
129 16307034 put_rac(c, state + 4 + log2, 0);
130
131
2/2
✓ Branch 0 taken 16640157 times.
✓ Branch 1 taken 16307034 times.
 32947191 for (int i = log2 - 1; i >= 0; i--)
132 16640157 put_rac(c, state + 31 - i, (v >> i) & 1);
133 16307034 }
134
135 521 static int get_encode_buffer(SnowContext *s, AVFrame *frame)
136 {
137 int ret;
138
139 521 frame->width = s->avctx->width + 2 * EDGE_WIDTH;
140 521 frame->height = s->avctx->height + 2 * EDGE_WIDTH;
141
142 521 ret = ff_encode_alloc_frame(s->avctx, frame);
143
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 521 times.
 521 if (ret < 0)
144 ✗ return ret;
145
2/2
✓ Branch 0 taken 1563 times.
✓ Branch 1 taken 521 times.
 2084 for (int i = 0; frame->data[i]; i++) {
146
2/2
✓ Branch 0 taken 1042 times.
✓ Branch 1 taken 521 times.
 1563 int offset = (EDGE_WIDTH >> (i ? s->chroma_v_shift : 0)) *
147 1563 frame->linesize[i] +
148
2/2
✓ Branch 0 taken 1042 times.
✓ Branch 1 taken 521 times.
 1563 (EDGE_WIDTH >> (i ? s->chroma_h_shift : 0));
149 1563 frame->data[i] += offset;
150 }
151 521 frame->width = s->avctx->width;
152 521 frame->height = s->avctx->height;
153
154 521 return 0;
155 }
156
157 11 static av_cold int encode_init(AVCodecContext *avctx)
158 {
159 11 SnowEncContext *const enc = avctx->priv_data;
160 11 SnowContext *const s = &enc->com;
161 11 MpegEncContext *const mpv = &enc->m;
162 int plane_index, ret;
163 int i;
164
165
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 3 times.
 11 if (enc->pred == DWT_97
166
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 && (avctx->flags & AV_CODEC_FLAG_QSCALE)
167
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 && avctx->global_quality == 0){
168 ✗ av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");
169 ✗ return AVERROR(EINVAL);
170 }
171
172 11 s->spatial_decomposition_type = enc->pred; //FIXME add decorrelator type r transform_type
173
174
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 3 times.
 11 s->mv_scale = (avctx->flags & AV_CODEC_FLAG_QPEL) ? 2 : 4;
175 11 s->block_max_depth= (avctx->flags & AV_CODEC_FLAG_4MV ) ? 1 : 0;
176
177
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 11 times.
 44 for(plane_index=0; plane_index<3; plane_index++){
178 33 s->plane[plane_index].diag_mc= 1;
179 33 s->plane[plane_index].htaps= 6;
180 33 s->plane[plane_index].hcoeff[0]= 40;
181 33 s->plane[plane_index].hcoeff[1]= -10;
182 33 s->plane[plane_index].hcoeff[2]= 2;
183 33 s->plane[plane_index].fast_mc= 1;
184 }
185
186 // Must be before ff_snow_common_init()
187 11 ff_hpeldsp_init(&s->hdsp, avctx->flags);
188
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
 11 if ((ret = ff_snow_common_init(avctx)) < 0) {
189 ✗ return ret;
190 }
191
192 #define mcf(dx,dy)\
193 enc->qdsp.put_qpel_pixels_tab [0][dy+dx/4]=\
194 enc->qdsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
195 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\
196 enc->qdsp.put_qpel_pixels_tab [1][dy+dx/4]=\
197 enc->qdsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
198 s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];
199
200 11 mcf( 0, 0)
201 11 mcf( 4, 0)
202 11 mcf( 8, 0)
203 11 mcf(12, 0)
204 11 mcf( 0, 4)
205 11 mcf( 4, 4)
206 11 mcf( 8, 4)
207 11 mcf(12, 4)
208 11 mcf( 0, 8)
209 11 mcf( 4, 8)
210 11 mcf( 8, 8)
211 11 mcf(12, 8)
212 11 mcf( 0,12)
213 11 mcf( 4,12)
214 11 mcf( 8,12)
215 11 mcf(12,12)
216
217 11 ff_me_cmp_init(&enc->mecc, avctx);
218 11 ff_mpegvideoencdsp_init(&enc->mpvencdsp, avctx);
219
220 11 ff_snow_alloc_blocks(s);
221
222 11 s->version=0;
223
224 11 mpv->avctx = avctx;
225 11 mpv->bit_rate= avctx->bit_rate;
226 11 mpv->lmin = avctx->mb_lmin;
227 11 mpv->lmax = avctx->mb_lmax;
228 11 mpv->mb_num = (avctx->width * avctx->height + 255) / 256; // For ratecontrol
229
230 11 mpv->me.temp =
231 11 mpv->me.scratchpad = av_calloc(avctx->width + 64, 2*16*2*sizeof(uint8_t));
232 11 mpv->sc.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
233 11 mpv->me.map = av_mallocz(2 * ME_MAP_SIZE * sizeof(*mpv->me.map));
234
3/6
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 11 times.
 11 if (!mpv->me.scratchpad || !mpv->me.map || !mpv->sc.obmc_scratchpad)
235 ✗ return AVERROR(ENOMEM);
236 11 mpv->me.score_map = mpv->me.map + ME_MAP_SIZE;
237
238 11 ff_h263_encode_init(mpv); //mv_penalty
239
240 11 s->max_ref_frames = av_clip(avctx->refs, 1, MAX_REF_FRAMES);
241
242
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if(avctx->flags&AV_CODEC_FLAG_PASS1){
243 ✗ if(!avctx->stats_out)
244 ✗ avctx->stats_out = av_mallocz(256);
245
246 ✗ if (!avctx->stats_out)
247 ✗ return AVERROR(ENOMEM);
248 }
249
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)){
250 ✗ ret = ff_rate_control_init(mpv);
251 ✗ if(ret < 0)
252 ✗ return ret;
253 }
254 11 enc->pass1_rc = !(avctx->flags & (AV_CODEC_FLAG_QSCALE|AV_CODEC_FLAG_PASS2));
255
256
1/3
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 11 switch(avctx->pix_fmt){
257 11 case AV_PIX_FMT_YUV444P:
258 // case AV_PIX_FMT_YUV422P:
259 case AV_PIX_FMT_YUV420P:
260 // case AV_PIX_FMT_YUV411P:
261 case AV_PIX_FMT_YUV410P:
262 11 s->nb_planes = 3;
263 11 s->colorspace_type= 0;
264 11 break;
265 ✗ case AV_PIX_FMT_GRAY8:
266 ✗ s->nb_planes = 1;
267 ✗ s->colorspace_type = 1;
268 ✗ break;
269 /* case AV_PIX_FMT_RGB32:
270 s->colorspace= 1;
271 break;*/
272 }
273
274 11 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift,
275 &s->chroma_v_shift);
276
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (ret)
277 ✗ return ret;
278
279 11 ret = ff_set_cmp(&enc->mecc, enc->mecc.me_cmp, s->avctx->me_cmp);
280 11 ret |= ff_set_cmp(&enc->mecc, enc->mecc.me_sub_cmp, s->avctx->me_sub_cmp);
281
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (ret < 0)
282 ✗ return AVERROR(EINVAL);
283
284 11 s->input_picture = av_frame_alloc();
285
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (!s->input_picture)
286 ✗ return AVERROR(ENOMEM);
287
288
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
 11 if ((ret = get_encode_buffer(s, s->input_picture)) < 0)
289 ✗ return ret;
290
291
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 5 times.
 11 if (enc->motion_est == FF_ME_ITER) {
292 6 int size= s->b_width * s->b_height << 2*s->block_max_depth;
293
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
 12 for(i=0; i<s->max_ref_frames; i++){
294 6 s->ref_mvs[i] = av_calloc(size, sizeof(*s->ref_mvs[i]));
295 6 s->ref_scores[i] = av_calloc(size, sizeof(*s->ref_scores[i]));
296
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])
297 ✗ return AVERROR(ENOMEM);
298 }
299 }
300
301 11 return 0;
302 }
303
304 //near copy & paste from dsputil, FIXME
305 1673460 static int pix_sum(const uint8_t * pix, int line_size, int w, int h)
306 {
307 int s, i, j;
308
309 1673460 s = 0;
310
2/2
✓ Branch 0 taken 11422080 times.
✓ Branch 1 taken 1673460 times.
 13095540 for (i = 0; i < h; i++) {
311
2/2
✓ Branch 0 taken 98496000 times.
✓ Branch 1 taken 11422080 times.
 109918080 for (j = 0; j < w; j++) {
312 98496000 s += pix[0];
313 98496000 pix ++;
314 }
315 11422080 pix += line_size - w;
316 }
317 1673460 return s;
318 }
319
320 //near copy & paste from dsputil, FIXME
321 557820 static int pix_norm1(const uint8_t * pix, int line_size, int w)
322 {
323 int s, i, j;
324 557820 const uint32_t *sq = ff_square_tab + 256;
325
326 557820 s = 0;
327
2/2
✓ Branch 0 taken 5711040 times.
✓ Branch 1 taken 557820 times.
 6268860 for (i = 0; i < w; i++) {
328
2/2
✓ Branch 0 taken 65664000 times.
✓ Branch 1 taken 5711040 times.
 71375040 for (j = 0; j < w; j ++) {
329 65664000 s += sq[pix[0]];
330 65664000 pix ++;
331 }
332 5711040 pix += line_size - w;
333 }
334 557820 return s;
335 }
336
337 1979900 static inline int get_penalty_factor(int lambda, int lambda2, int type){
338
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){
339 1374300 default:
340 case FF_CMP_SAD:
341 1374300 return lambda>>FF_LAMBDA_SHIFT;
342 ✗ case FF_CMP_DCT:
343 ✗ return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
344 ✗ case FF_CMP_W53:
345 ✗ return (4*lambda)>>(FF_LAMBDA_SHIFT);
346 323720 case FF_CMP_W97:
347 323720 return (2*lambda)>>(FF_LAMBDA_SHIFT);
348 ✗ case FF_CMP_SATD:
349 case FF_CMP_DCT264:
350 ✗ return (2*lambda)>>FF_LAMBDA_SHIFT;
351 281880 case FF_CMP_RD:
352 case FF_CMP_PSNR:
353 case FF_CMP_SSE:
354 case FF_CMP_NSSE:
355 281880 return lambda2>>FF_LAMBDA_SHIFT;
356 ✗ case FF_CMP_BIT:
357 ✗ return 1;
358 }
359 }
360
361 //FIXME copy&paste
362 #define P_LEFT P[1]
363 #define P_TOP P[2]
364 #define P_TOPRIGHT P[3]
365 #define P_MEDIAN P[4]
366 #define P_MV1 P[9]
367 #define FLAG_QPEL 1 //must be 1
368
369 567000 static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
370 {
371 567000 SnowContext *const s = &enc->com;
372 567000 MotionEstContext *const c = &enc->m.me;
373 uint8_t p_buffer[1024];
374 uint8_t i_buffer[1024];
375 uint8_t p_state[sizeof(s->block_state)];
376 uint8_t i_state[sizeof(s->block_state)];
377 RangeCoder pc, ic;
378 567000 uint8_t *pbbak= s->c.bytestream;
379 567000 uint8_t *pbbak_start= s->c.bytestream_start;
380 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
381 567000 const int w= s->b_width << s->block_max_depth;
382 567000 const int h= s->b_height << s->block_max_depth;
383 567000 const int rem_depth= s->block_max_depth - level;
384 567000 const int index= (x + y*w) << rem_depth;
385 567000 const int block_w= 1<<(LOG2_MB_SIZE - level);
386 567000 int trx= (x+1)<<rem_depth;
387 567000 int try= (y+1)<<rem_depth;
388
2/2
✓ Branch 0 taken 554112 times.
✓ Branch 1 taken 12888 times.
 567000 const BlockNode *left = x ? &s->block[index-1] : &null_block;
389
2/2
✓ Branch 0 taken 550290 times.
✓ Branch 1 taken 16710 times.
 567000 const BlockNode *top = y ? &s->block[index-w] : &null_block;
390
2/2
✓ Branch 0 taken 554112 times.
✓ Branch 1 taken 12888 times.
 567000 const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
391
2/2
✓ Branch 0 taken 550290 times.
✓ Branch 1 taken 16710 times.
 567000 const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
392
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;
393
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
394 567000 int pl = left->color[0];
395 567000 int pcb= left->color[1];
396 567000 int pcr= left->color[2];
397 int pmx, pmy;
398 567000 int mx=0, my=0;
399 int l,cr,cb;
400 567000 const int stride= s->current_picture->linesize[0];
401 567000 const int uvstride= s->current_picture->linesize[1];
402 567000 const uint8_t *const current_data[3] = { s->input_picture->data[0] + (x + y* stride)*block_w,
403 567000 s->input_picture->data[1] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift),
404 567000 s->input_picture->data[2] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift)};
405 int P[10][2];
406 int16_t last_mv[3][2];
407 567000 int qpel= !!(s->avctx->flags & AV_CODEC_FLAG_QPEL); //unused
408 567000 const int shift= 1+qpel;
409 567000 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
410 567000 int mx_context= av_log2(2*FFABS(left->mx - top->mx));
411 567000 int my_context= av_log2(2*FFABS(left->my - top->my));
412 567000 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
413 int ref, best_ref, ref_score, ref_mx, ref_my;
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.mb_stride = 2;
438 557820 enc->m.mb_x =
439 557820 enc->m.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.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
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);
456
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);
457
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);
458
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);
459
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));
460
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
461
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);
462
463 557820 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
464 557820 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
465
466
2/2
✓ Branch 0 taken 16290 times.
✓ Branch 1 taken 541530 times.
 557820 if (!y) {
467 16290 c->pred_x= P_LEFT[0];
468 16290 c->pred_y= P_LEFT[1];
469 } else {
470 541530 c->pred_x = P_MEDIAN[0];
471 541530 c->pred_y = P_MEDIAN[1];
472 }
473
474 557820 score= INT_MAX;
475 557820 best_ref= 0;
476
2/2
✓ Branch 0 taken 557820 times.
✓ Branch 1 taken 557820 times.
 1115640 for(ref=0; ref<s->ref_frames; ref++){
477 557820 init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);
478
479 557820 ref_score= ff_epzs_motion_search(&enc->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
480 (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
481
482 av_assert2(ref_mx >= c->xmin);
483 av_assert2(ref_mx <= c->xmax);
484 av_assert2(ref_my >= c->ymin);
485 av_assert2(ref_my <= c->ymax);
486
487 557820 ref_score= c->sub_motion_search(&enc->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
488 557820 ref_score= ff_get_mb_score(&enc->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
489 557820 ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
490
2/2
✓ Branch 0 taken 8640 times.
✓ Branch 1 taken 549180 times.
 557820 if(s->ref_mvs[ref]){
491 8640 s->ref_mvs[ref][index][0]= ref_mx;
492 8640 s->ref_mvs[ref][index][1]= ref_my;
493 8640 s->ref_scores[ref][index]= ref_score;
494 }
495
1/2
✓ Branch 0 taken 557820 times.
✗ Branch 1 not taken.
 557820 if(score > ref_score){
496 557820 score= ref_score;
497 557820 best_ref= ref;
498 557820 mx= ref_mx;
499 557820 my= ref_my;
500 }
501 }
502 //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
503
504 // subpel search
505 557820 base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
506 557820 pc= s->c;
507 557820 pc.bytestream_start=
508 557820 pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
509 557820 memcpy(p_state, s->block_state, sizeof(s->block_state));
510
511
2/2
✓ Branch 0 taken 100440 times.
✓ Branch 1 taken 457380 times.
 557820 if(level!=s->block_max_depth)
512 100440 put_rac(&pc, &p_state[4 + s_context], 1);
513 557820 put_rac(&pc, &p_state[1 + left->type + top->type], 0);
514
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 557820 times.
 557820 if(s->ref_frames > 1)
515 ✗ put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
516 557820 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
517
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);
518
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);
519 557820 p_len= pc.bytestream - pc.bytestream_start;
520 557820 score += (enc->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
521
522 557820 block_s= block_w*block_w;
523 557820 sum = pix_sum(current_data[0], stride, block_w, block_w);
524 557820 l= (sum + block_s/2)/block_s;
525 557820 iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
526
527
1/2
✓ Branch 0 taken 557820 times.
✗ Branch 1 not taken.
 557820 if (s->nb_planes > 2) {
528 557820 block_s= block_w*block_w>>(s->chroma_h_shift + s->chroma_v_shift);
529 557820 sum = pix_sum(current_data[1], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
530 557820 cb= (sum + block_s/2)/block_s;
531 // iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
532 557820 sum = pix_sum(current_data[2], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
533 557820 cr= (sum + block_s/2)/block_s;
534 // iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
535 }else
536 ✗ cb = cr = 0;
537
538 557820 ic= s->c;
539 557820 ic.bytestream_start=
540 557820 ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
541 557820 memcpy(i_state, s->block_state, sizeof(s->block_state));
542
2/2
✓ Branch 0 taken 100440 times.
✓ Branch 1 taken 457380 times.
 557820 if(level!=s->block_max_depth)
543 100440 put_rac(&ic, &i_state[4 + s_context], 1);
544 557820 put_rac(&ic, &i_state[1 + left->type + top->type], 1);
545 557820 put_symbol(&ic, &i_state[32], l-pl , 1);
546
1/2
✓ Branch 0 taken 557820 times.
✗ Branch 1 not taken.
 557820 if (s->nb_planes > 2) {
547 557820 put_symbol(&ic, &i_state[64], cb-pcb, 1);
548 557820 put_symbol(&ic, &i_state[96], cr-pcr, 1);
549 }
550 557820 i_len= ic.bytestream - ic.bytestream_start;
551 557820 iscore += (enc->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
552
553 av_assert1(iscore < 255*255*256 + enc->lambda2*10);
554 av_assert1(iscore >= 0);
555 av_assert1(l>=0 && l<=255);
556 av_assert1(pl>=0 && pl<=255);
557
558
2/2
✓ Branch 0 taken 156060 times.
✓ Branch 1 taken 401760 times.
 557820 if(level==0){
559 156060 int varc= iscore >> 8;
560 156060 int vard= score >> 8;
561
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)
562 134302 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
563 else
564 21758 c->scene_change_score += enc->m.qscale;
565 }
566
567
2/2
✓ Branch 0 taken 100440 times.
✓ Branch 1 taken 457380 times.
 557820 if(level!=s->block_max_depth){
568 100440 put_rac(&s->c, &s->block_state[4 + s_context], 0);
569 100440 score2 = encode_q_branch(enc, level+1, 2*x+0, 2*y+0);
570 100440 score2+= encode_q_branch(enc, level+1, 2*x+1, 2*y+0);
571 100440 score2+= encode_q_branch(enc, level+1, 2*x+0, 2*y+1);
572 100440 score2+= encode_q_branch(enc, level+1, 2*x+1, 2*y+1);
573 100440 score2+= enc->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
574
575
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)
576 88580 return score2;
577 }
578
579
2/2
✓ Branch 0 taken 82082 times.
✓ Branch 1 taken 387158 times.
 469240 if(iscore < score){
580 82082 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
581 82082 memcpy(pbbak, i_buffer, i_len);
582 82082 s->c= ic;
583 82082 s->c.bytestream_start= pbbak_start;
584 82082 s->c.bytestream= pbbak + i_len;
585 82082 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);
586 82082 memcpy(s->block_state, i_state, sizeof(s->block_state));
587 82082 return iscore;
588 }else{
589 387158 memcpy(pbbak, p_buffer, p_len);
590 387158 s->c= pc;
591 387158 s->c.bytestream_start= pbbak_start;
592 387158 s->c.bytestream= pbbak + p_len;
593 387158 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
594 387158 memcpy(s->block_state, p_state, sizeof(s->block_state));
595 387158 return score;
596 }
597 }
598
599 9600 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
600 9600 const int w= s->b_width << s->block_max_depth;
601 9600 const int rem_depth= s->block_max_depth - level;
602 9600 const int index= (x + y*w) << rem_depth;
603 9600 int trx= (x+1)<<rem_depth;
604 9600 BlockNode *b= &s->block[index];
605
2/2
✓ Branch 0 taken 8400 times.
✓ Branch 1 taken 1200 times.
 9600 const BlockNode *left = x ? &s->block[index-1] : &null_block;
606
2/2
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 2400 times.
 9600 const BlockNode *top = y ? &s->block[index-w] : &null_block;
607
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;
608
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
609 9600 int pl = left->color[0];
610 9600 int pcb= left->color[1];
611 9600 int pcr= left->color[2];
612 int pmx, pmy;
613 9600 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
614
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;
615
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;
616 9600 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
617
618
2/2
✓ Branch 0 taken 960 times.
✓ Branch 1 taken 8640 times.
 9600 if(s->keyframe){
619 960 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
620 960 return;
621 }
622
623
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8640 times.
 8640 if(level!=s->block_max_depth){
624 ✗ if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
625 ✗ put_rac(&s->c, &s->block_state[4 + s_context], 1);
626 }else{
627 ✗ put_rac(&s->c, &s->block_state[4 + s_context], 0);
628 ✗ encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
629 ✗ encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
630 ✗ encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
631 ✗ encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
632 ✗ return;
633 }
634 }
635
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 8593 times.
 8640 if(b->type & BLOCK_INTRA){
636 47 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
637 47 put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
638 47 put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
639
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
 47 if (s->nb_planes > 2) {
640 47 put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
641 47 put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
642 }
643 47 set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);
644 }else{
645 8593 pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
646 8593 put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
647
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8593 times.
 8593 if(s->ref_frames > 1)
648 ✗ put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);
649 8593 put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
650 8593 put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
651 8593 set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);
652 }
653 }
654
655 54714 static int get_dc(SnowEncContext *enc, int mb_x, int mb_y, int plane_index)
656 {
657 54714 SnowContext *const s = &enc->com;
658 int i, x2, y2;
659 54714 Plane *p= &s->plane[plane_index];
660 54714 const int block_size = MB_SIZE >> s->block_max_depth;
661
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;
662
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;
663
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];
664
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;
665 54714 const int ref_stride= s->current_picture->linesize[plane_index];
666 54714 const uint8_t *src = s->input_picture->data[plane_index];
667 54714 IDWTELEM *dst= (IDWTELEM*)enc->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
668 54714 const int b_stride = s->b_width << s->block_max_depth;
669 54714 const int w= p->width;
670 54714 const int h= p->height;
671 54714 int index= mb_x + mb_y*b_stride;
672 54714 BlockNode *b= &s->block[index];
673 54714 BlockNode backup= *b;
674 54714 int ab=0;
675 54714 int aa=0;
676
677 av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc stuff above
678
679 54714 b->type|= BLOCK_INTRA;
680 54714 b->color[plane_index]= 0;
681 54714 memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
682
683
2/2
✓ Branch 0 taken 218856 times.
✓ Branch 1 taken 54714 times.
 273570 for(i=0; i<4; i++){
684 218856 int mb_x2= mb_x + (i &1) - 1;
685 218856 int mb_y2= mb_y + (i>>1) - 1;
686 218856 int x= block_w*mb_x2 + block_w/2;
687 218856 int y= block_h*mb_y2 + block_h/2;
688
689 218856 add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,
690 x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
691
692
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++){
693
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++){
694 23411232 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
695 23411232 int obmc_v= obmc[index];
696 int d;
697
2/2
✓ Branch 0 taken 1795776 times.
✓ Branch 1 taken 21615456 times.
 23411232 if(y<0) obmc_v += obmc[index + block_h*obmc_stride];
698
2/2
✓ Branch 0 taken 762816 times.
✓ Branch 1 taken 22648416 times.
 23411232 if(x<0) obmc_v += obmc[index + block_w];
699
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];
700
2/2
✓ Branch 0 taken 600864 times.
✓ Branch 1 taken 22810368 times.
 23411232 if(x+block_w>w) obmc_v += obmc[index - block_w];
701 //FIXME precalculate this or simplify it somehow else
702
703 23411232 d = -dst[index] + (1<<(FRAC_BITS-1));
704 23411232 dst[index] = d;
705 23411232 ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;
706 23411232 aa += obmc_v * obmc_v; //FIXME precalculate this
707 }
708 }
709 }
710 54714 *b= backup;
711
712
2/2
✓ Branch 0 taken 54643 times.
✓ Branch 1 taken 71 times.
 54714 return av_clip_uint8( ROUNDED_DIV(ab<<LOG2_OBMC_MAX, aa) ); //FIXME we should not need clipping
713 }
714
715 1263062 static inline int get_block_bits(SnowContext *s, int x, int y, int w){
716 1263062 const int b_stride = s->b_width << s->block_max_depth;
717 1263062 const int b_height = s->b_height<< s->block_max_depth;
718 1263062 int index= x + y*b_stride;
719 1263062 const BlockNode *b = &s->block[index];
720
2/2
✓ Branch 0 taken 1142570 times.
✓ Branch 1 taken 120492 times.
 1263062 const BlockNode *left = x ? &s->block[index-1] : &null_block;
721
2/2
✓ Branch 0 taken 1098940 times.
✓ Branch 1 taken 164122 times.
 1263062 const BlockNode *top = y ? &s->block[index-b_stride] : &null_block;
722
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;
723
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;
724 int dmx, dmy;
725 // int mx_context= av_log2(2*FFABS(left->mx - top->mx));
726 // int my_context= av_log2(2*FFABS(left->my - top->my));
727
728
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)
729 187848 return 0;
730 /*
731 1 0 0
732 01X 1-2 1
733 001XX 3-6 2-3
734 0001XXX 7-14 4-7
735 00001XXXX 15-30 8-15
736 */
737 //FIXME try accurate rate
738 //FIXME intra and inter predictors if surrounding blocks are not the same type
739
2/2
✓ Branch 0 taken 22775 times.
✓ Branch 1 taken 1052439 times.
 1075214 if(b->type & BLOCK_INTRA){
740 22775 return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))
741 22775 + av_log2(2*FFABS(left->color[1] - b->color[1]))
742 22775 + av_log2(2*FFABS(left->color[2] - b->color[2])));
743 }else{
744 1052439 pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);
745 1052439 dmx-= b->mx;
746 1052439 dmy-= b->my;
747 1052439 return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda
748 1052439 + av_log2(2*FFABS(dmy))
749 1052439 + av_log2(2*b->ref));
750 }
751 }
752
753 306440 static int get_block_rd(SnowEncContext *enc, int mb_x, int mb_y,
754 int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2])
755 {
756 306440 SnowContext *const s = &enc->com;
757 306440 Plane *p= &s->plane[plane_index];
758 306440 const int block_size = MB_SIZE >> s->block_max_depth;
759
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;
760
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;
761
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;
762 306440 const int ref_stride= s->current_picture->linesize[plane_index];
763 306440 uint8_t *dst= s->current_picture->data[plane_index];
764 306440 const uint8_t *src = s->input_picture->data[plane_index];
765 306440 IDWTELEM *pred= (IDWTELEM*)enc->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
766 306440 uint8_t *cur = s->scratchbuf;
767 306440 uint8_t *tmp = s->emu_edge_buffer;
768 306440 const int b_stride = s->b_width << s->block_max_depth;
769 306440 const int b_height = s->b_height<< s->block_max_depth;
770 306440 const int w= p->width;
771 306440 const int h= p->height;
772 int distortion;
773 306440 int rate= 0;
774 306440 const int penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, s->avctx->me_cmp);
775 306440 int sx= block_w*mb_x - block_w/2;
776 306440 int sy= block_h*mb_y - block_h/2;
777 306440 int x0= FFMAX(0,-sx);
778 306440 int y0= FFMAX(0,-sy);
779 306440 int x1= FFMIN(block_w*2, w-sx);
780 306440 int y1= FFMIN(block_h*2, h-sy);
781 int i,x,y;
782
783 av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below chckinhg only block_w
784
785 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);
786
787
2/2
✓ Branch 0 taken 8675728 times.
✓ Branch 1 taken 306440 times.
 8982168 for(y=y0; y<y1; y++){
788 8675728 const uint8_t *obmc1= obmc_edged[y];
789 8675728 const IDWTELEM *pred1 = pred + y*obmc_stride;
790 8675728 uint8_t *cur1 = cur + y*ref_stride;
791 8675728 uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
792
2/2
✓ Branch 0 taken 262001664 times.
✓ Branch 1 taken 8675728 times.
 270677392 for(x=x0; x<x1; x++){
793 #if FRAC_BITS >= LOG2_OBMC_MAX
794 int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);
795 #else
796 262001664 int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);
797 #endif
798 262001664 v = (v + pred1[x]) >> FRAC_BITS;
799
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 262001664 times.
 262001664 if(v&(~255)) v= ~(v>>31);
800 262001664 dst1[x] = v;
801 }
802 }
803
804 /* copy the regions where obmc[] = (uint8_t)256 */
805
2/2
✓ Branch 0 taken 267895 times.
✓ Branch 1 taken 38545 times.
 306440 if(LOG2_OBMC_MAX == 8
806
2/2
✓ Branch 0 taken 30258 times.
✓ Branch 1 taken 237637 times.
 267895 && (mb_x == 0 || mb_x == b_stride-1)
807
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)){
808
2/2
✓ Branch 0 taken 17393 times.
✓ Branch 1 taken 13731 times.
 31124 if(mb_x == 0)
809 17393 x1 = block_w;
810 else
811 13731 x0 = block_w;
812
2/2
✓ Branch 0 taken 18162 times.
✓ Branch 1 taken 12962 times.
 31124 if(mb_y == 0)
813 18162 y1 = block_h;
814 else
815 12962 y0 = block_h;
816
2/2
✓ Branch 0 taken 248992 times.
✓ Branch 1 taken 31124 times.
 280116 for(y=y0; y<y1; y++)
817 248992 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
818 }
819
820
1/2
✓ Branch 0 taken 306440 times.
✗ Branch 1 not taken.
 306440 if(block_w==16){
821 /* FIXME rearrange dsputil to fit 32x32 cmp functions */
822 /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */
823 /* FIXME cmps overlap but do not cover the wavelet's whole support.
824 * So improving the score of one block is not strictly guaranteed
825 * to improve the score of the whole frame, thus iterative motion
826 * estimation does not always converge. */
827
1/2
✓ Branch 0 taken 306440 times.
✗ Branch 1 not taken.
 306440 if(s->avctx->me_cmp == FF_CMP_W97)
828 306440 distortion = ff_w97_32_c(&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
829 ✗ else if(s->avctx->me_cmp == FF_CMP_W53)
830 ✗ distortion = ff_w53_32_c(&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
831 else{
832 ✗ distortion = 0;
833 ✗ for(i=0; i<4; i++){
834 ✗ int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
835 ✗ distortion += enc->mecc.me_cmp[0](&enc->m, src + off, dst + off, ref_stride, 16);
836 }
837 }
838 }else{
839 av_assert2(block_w==8);
840 ✗ distortion = enc->mecc.me_cmp[0](&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
841 }
842
843
1/2
✓ Branch 0 taken 306440 times.
✗ Branch 1 not taken.
 306440 if(plane_index==0){
844
2/2
✓ Branch 0 taken 1225760 times.
✓ Branch 1 taken 306440 times.
 1532200 for(i=0; i<4; i++){
845 /* ..RRr
846 * .RXx.
847 * rxx..
848 */
849 1225760 rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
850 }
851
2/2
✓ Branch 0 taken 37302 times.
✓ Branch 1 taken 269138 times.
 306440 if(mb_x == b_stride-2)
852 37302 rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
853 }
854 306440 return distortion + rate*penalty_factor;
855 }
856
857 ✗ static int get_4block_rd(SnowEncContext *enc, int mb_x, int mb_y, int plane_index)
858 {
859 ✗ SnowContext *const s = &enc->com;
860 int i, y2;
861 ✗ Plane *p= &s->plane[plane_index];
862 ✗ const int block_size = MB_SIZE >> s->block_max_depth;
863 ✗ const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
864 ✗ const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
865 ✗ const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
866 ✗ const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
867 ✗ const int ref_stride= s->current_picture->linesize[plane_index];
868 ✗ uint8_t *dst= s->current_picture->data[plane_index];
869 ✗ const uint8_t *src = s->input_picture->data[plane_index];
870 //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst
871 // const has only been removed from zero_dst to suppress a warning
872 static IDWTELEM zero_dst[4096]; //FIXME
873 ✗ const int b_stride = s->b_width << s->block_max_depth;
874 ✗ const int w= p->width;
875 ✗ const int h= p->height;
876 ✗ int distortion= 0;
877 ✗ int rate= 0;
878 ✗ const int penalty_factor= get_penalty_factor(enc->lambda, enc->lambda2, s->avctx->me_cmp);
879
880 av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below
881
882 ✗ for(i=0; i<9; i++){
883 ✗ int mb_x2= mb_x + (i%3) - 1;
884 ✗ int mb_y2= mb_y + (i/3) - 1;
885 ✗ int x= block_w*mb_x2 + block_w/2;
886 ✗ int y= block_h*mb_y2 + block_h/2;
887
888 ✗ add_yblock(s, 0, NULL, zero_dst, dst, obmc,
889 x, y, block_w, block_h, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
890
891 //FIXME find a cleaner/simpler way to skip the outside stuff
892 ✗ for(y2= y; y2<0; y2++)
893 ✗ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
894 ✗ for(y2= h; y2<y+block_h; y2++)
895 ✗ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
896 ✗ if(x<0){
897 ✗ for(y2= y; y2<y+block_h; y2++)
898 ✗ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
899 }
900 ✗ if(x+block_w > w){
901 ✗ for(y2= y; y2<y+block_h; y2++)
902 ✗ memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
903 }
904
905 av_assert1(block_w== 8 || block_w==16);
906 ✗ distortion += enc->mecc.me_cmp[block_w==8](&enc->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
907 }
908
909 ✗ if(plane_index==0){
910 ✗ BlockNode *b= &s->block[mb_x+mb_y*b_stride];
911 ✗ int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);
912
913 /* ..RRRr
914 * .RXXx.
915 * .RXXx.
916 * rxxx.
917 */
918 ✗ if(merged)
919 ✗ rate = get_block_bits(s, mb_x, mb_y, 2);
920 ✗ for(i=merged?4:0; i<9; i++){
921 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
922 ✗ rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
923 }
924 }
925 ✗ return distortion + rate*penalty_factor;
926 }
927
928 21600 static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
929 21600 const int w= b->width;
930 21600 const int h= b->height;
931 int x, y;
932
933 if(1){
934 21600 int run=0;
935 21600 int *runs = s->run_buffer;
936 21600 int run_index=0;
937 int max_index;
938
939
2/2
✓ Branch 0 taken 366600 times.
✓ Branch 1 taken 21600 times.
 388200 for(y=0; y<h; y++){
940
2/2
✓ Branch 0 taken 26496000 times.
✓ Branch 1 taken 366600 times.
 26862600 for(x=0; x<w; x++){
941 26496000 int v, p=0;
942 26496000 int /*ll=0, */l=0, lt=0, t=0, rt=0;
943 26496000 v= src[x + y*stride];
944
945
2/2
✓ Branch 0 taken 25960200 times.
✓ Branch 1 taken 535800 times.
 26496000 if(y){
946 25960200 t= src[x + (y-1)*stride];
947
2/2
✓ Branch 0 taken 25615200 times.
✓ Branch 1 taken 345000 times.
 25960200 if(x){
948 25615200 lt= src[x - 1 + (y-1)*stride];
949 }
950
2/2
✓ Branch 0 taken 25615200 times.
✓ Branch 1 taken 345000 times.
 25960200 if(x + 1 < w){
951 25615200 rt= src[x + 1 + (y-1)*stride];
952 }
953 }
954
2/2
✓ Branch 0 taken 26129400 times.
✓ Branch 1 taken 366600 times.
 26496000 if(x){
955 26129400 l= src[x - 1 + y*stride];
956 /*if(x > 1){
957 if(orientation==1) ll= src[y + (x-2)*stride];
958 else ll= src[x - 2 + y*stride];
959 }*/
960 }
961
2/2
✓ Branch 0 taken 26392500 times.
✓ Branch 1 taken 103500 times.
 26496000 if(parent){
962 26392500 int px= x>>1;
963 26392500 int py= y>>1;
964
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)
965 26380800 p= parent[px + py*2*stride];
966 }
967
2/2
✓ Branch 0 taken 2820074 times.
✓ Branch 1 taken 23675926 times.
 26496000 if(!(/*ll|*/l|lt|t|rt|p)){
968
2/2
✓ Branch 0 taken 291706 times.
✓ Branch 1 taken 2528368 times.
 2820074 if(v){
969 291706 runs[run_index++]= run;
970 291706 run=0;
971 }else{
972 2528368 run++;
973 }
974 }
975 }
976 }
977 21600 max_index= run_index;
978 21600 runs[run_index++]= run;
979 21600 run_index=0;
980 21600 run= runs[run_index++];
981
982 21600 put_symbol2(&s->c, b->state[30], max_index, 0);
983
2/2
✓ Branch 0 taken 16975 times.
✓ Branch 1 taken 4625 times.
 21600 if(run_index <= max_index)
984 16975 put_symbol2(&s->c, b->state[1], run, 3);
985
986
2/2
✓ Branch 0 taken 366600 times.
✓ Branch 1 taken 21600 times.
 388200 for(y=0; y<h; y++){
987
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 366600 times.
 366600 if(s->c.bytestream_end - s->c.bytestream < w*40){
988 ✗ av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
989 ✗ return AVERROR(ENOMEM);
990 }
991
2/2
✓ Branch 0 taken 26496000 times.
✓ Branch 1 taken 366600 times.
 26862600 for(x=0; x<w; x++){
992 26496000 int v, p=0;
993 26496000 int /*ll=0, */l=0, lt=0, t=0, rt=0;
994 26496000 v= src[x + y*stride];
995
996
2/2
✓ Branch 0 taken 25960200 times.
✓ Branch 1 taken 535800 times.
 26496000 if(y){
997 25960200 t= src[x + (y-1)*stride];
998
2/2
✓ Branch 0 taken 25615200 times.
✓ Branch 1 taken 345000 times.
 25960200 if(x){
999 25615200 lt= src[x - 1 + (y-1)*stride];
1000 }
1001
2/2
✓ Branch 0 taken 25615200 times.
✓ Branch 1 taken 345000 times.
 25960200 if(x + 1 < w){
1002 25615200 rt= src[x + 1 + (y-1)*stride];
1003 }
1004 }
1005
2/2
✓ Branch 0 taken 26129400 times.
✓ Branch 1 taken 366600 times.
 26496000 if(x){
1006 26129400 l= src[x - 1 + y*stride];
1007 /*if(x > 1){
1008 if(orientation==1) ll= src[y + (x-2)*stride];
1009 else ll= src[x - 2 + y*stride];
1010 }*/
1011 }
1012
2/2
✓ Branch 0 taken 26392500 times.
✓ Branch 1 taken 103500 times.
 26496000 if(parent){
1013 26392500 int px= x>>1;
1014 26392500 int py= y>>1;
1015
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)
1016 26380800 p= parent[px + py*2*stride];
1017 }
1018
2/2
✓ Branch 0 taken 23675926 times.
✓ Branch 1 taken 2820074 times.
 26496000 if(/*ll|*/l|lt|t|rt|p){
1019 23675926 int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
1020
1021 23675926 put_rac(&s->c, &b->state[0][context], !!v);
1022 }else{
1023
2/2
✓ Branch 0 taken 291706 times.
✓ Branch 1 taken 2528368 times.
 2820074 if(!run){
1024 291706 run= runs[run_index++];
1025
1026
2/2
✓ Branch 0 taken 274731 times.
✓ Branch 1 taken 16975 times.
 291706 if(run_index <= max_index)
1027 274731 put_symbol2(&s->c, b->state[1], run, 3);
1028 av_assert2(v);
1029 }else{
1030 2528368 run--;
1031 av_assert2(!v);
1032 }
1033 }
1034
2/2
✓ Branch 0 taken 15993728 times.
✓ Branch 1 taken 10502272 times.
 26496000 if(v){
1035 15993728 int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
1036 15993728 int l2= 2*FFABS(l) + (l<0);
1037 15993728 int t2= 2*FFABS(t) + (t<0);
1038
1039 15993728 put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);
1040 15993728 put_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l2&0xFF] + 3*ff_quant3bA[t2&0xFF]], v<0);
1041 }
1042 }
1043 }
1044 }
1045 21600 return 0;
1046 }
1047
1048 21600 static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
1049 // encode_subband_qtree(s, b, src, parent, stride, orientation);
1050 // encode_subband_z0run(s, b, src, parent, stride, orientation);
1051 21600 return encode_subband_c0run(s, b, src, parent, stride, orientation);
1052 // encode_subband_dzr(s, b, src, parent, stride, orientation);
1053 }
1054
1055 18314 static av_always_inline int check_block_intra(SnowEncContext *enc, int mb_x, int mb_y, int p[3],
1056 uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd)
1057 {
1058 18314 SnowContext *const s = &enc->com;
1059 18314 const int b_stride= s->b_width << s->block_max_depth;
1060 18314 BlockNode *block= &s->block[mb_x + mb_y * b_stride];
1061 18314 BlockNode backup= *block;
1062 int rd;
1063
1064 av_assert2(mb_x>=0 && mb_y>=0);
1065 av_assert2(mb_x<b_stride);
1066
1067 18314 block->color[0] = p[0];
1068 18314 block->color[1] = p[1];
1069 18314 block->color[2] = p[2];
1070 18314 block->type |= BLOCK_INTRA;
1071
1072 18314 rd = get_block_rd(enc, mb_x, mb_y, 0, obmc_edged) + enc->intra_penalty;
1073
1074 //FIXME chroma
1075
2/2
✓ Branch 0 taken 135 times.
✓ Branch 1 taken 18179 times.
 18314 if(rd < *best_rd){
1076 135 *best_rd= rd;
1077 135 return 1;
1078 }else{
1079 18179 *block= backup;
1080 18179 return 0;
1081 }
1082 }
1083
1084 /* special case for int[2] args we discard afterwards,
1085 * fixes compilation problem with gcc 2.95 */
1086 404968 static av_always_inline int check_block_inter(SnowEncContext *enc,
1087 int mb_x, int mb_y, int p0, int p1,
1088 uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd)
1089 {
1090 404968 SnowContext *const s = &enc->com;
1091 404968 const int b_stride = s->b_width << s->block_max_depth;
1092 404968 BlockNode *block = &s->block[mb_x + mb_y * b_stride];
1093 404968 BlockNode backup = *block;
1094 unsigned value;
1095 int rd, index;
1096
1097 av_assert2(mb_x >= 0 && mb_y >= 0);
1098 av_assert2(mb_x < b_stride);
1099
1100 404968 index = (p0 + 31 * p1) & (ME_CACHE_SIZE-1);
1101 404968 value = enc->me_cache_generation + (p0 >> 10) + p1 * (1 << 6) + (block->ref << 12);
1102
2/2
✓ Branch 0 taken 116842 times.
✓ Branch 1 taken 288126 times.
 404968 if (enc->me_cache[index] == value)
1103 116842 return 0;
1104 288126 enc->me_cache[index] = value;
1105
1106 288126 block->mx = p0;
1107 288126 block->my = p1;
1108 288126 block->type &= ~BLOCK_INTRA;
1109
1110 288126 rd = get_block_rd(enc, mb_x, mb_y, 0, obmc_edged);
1111
1112 //FIXME chroma
1113
2/2
✓ Branch 0 taken 63690 times.
✓ Branch 1 taken 224436 times.
 288126 if (rd < *best_rd) {
1114 63690 *best_rd = rd;
1115 63690 return 1;
1116 } else {
1117 224436 *block = backup;
1118 224436 return 0;
1119 }
1120 }
1121
1122 ✗ static av_always_inline int check_4block_inter(SnowEncContext *enc, int mb_x, int mb_y,
1123 int p0, int p1, int ref, int *best_rd)
1124 {
1125 ✗ SnowContext *const s = &enc->com;
1126 ✗ const int b_stride= s->b_width << s->block_max_depth;
1127 ✗ BlockNode *block= &s->block[mb_x + mb_y * b_stride];
1128 BlockNode backup[4];
1129 unsigned value;
1130 int rd, index;
1131
1132 /* We don't initialize backup[] during variable declaration, because
1133 * that fails to compile on MSVC: "cannot convert from 'BlockNode' to
1134 * 'int16_t'". */
1135 ✗ backup[0] = block[0];
1136 ✗ backup[1] = block[1];
1137 ✗ backup[2] = block[b_stride];
1138 ✗ backup[3] = block[b_stride + 1];
1139
1140 av_assert2(mb_x>=0 && mb_y>=0);
1141 av_assert2(mb_x<b_stride);
1142 av_assert2(((mb_x|mb_y)&1) == 0);
1143
1144 ✗ index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);
1145 ✗ value = enc->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);
1146 ✗ if (enc->me_cache[index] == value)
1147 ✗ return 0;
1148 ✗ enc->me_cache[index] = value;
1149
1150 ✗ block->mx= p0;
1151 ✗ block->my= p1;
1152 ✗ block->ref= ref;
1153 ✗ block->type &= ~BLOCK_INTRA;
1154 ✗ block[1]= block[b_stride]= block[b_stride+1]= *block;
1155
1156 ✗ rd = get_4block_rd(enc, mb_x, mb_y, 0);
1157
1158 //FIXME chroma
1159 ✗ if(rd < *best_rd){
1160 ✗ *best_rd= rd;
1161 ✗ return 1;
1162 }else{
1163 ✗ block[0]= backup[0];
1164 ✗ block[1]= backup[1];
1165 ✗ block[b_stride]= backup[2];
1166 ✗ block[b_stride+1]= backup[3];
1167 ✗ return 0;
1168 }
1169 }
1170
1171 270 static void iterative_me(SnowEncContext *enc)
1172 {
1173 270 SnowContext *const s = &enc->com;
1174 int pass, mb_x, mb_y;
1175 270 const int b_width = s->b_width << s->block_max_depth;
1176 270 const int b_height= s->b_height << s->block_max_depth;
1177 270 const int b_stride= b_width;
1178 int color[3];
1179
1180 {
1181 270 RangeCoder r = s->c;
1182 uint8_t state[sizeof(s->block_state)];
1183 270 memcpy(state, s->block_state, sizeof(s->block_state));
1184
2/2
✓ Branch 0 taken 1080 times.
✓ Branch 1 taken 270 times.
 1350 for(mb_y= 0; mb_y<s->b_height; mb_y++)
1185
2/2
✓ Branch 0 taken 8640 times.
✓ Branch 1 taken 1080 times.
 9720 for(mb_x= 0; mb_x<s->b_width; mb_x++)
1186 8640 encode_q_branch(enc, 0, mb_x, mb_y);
1187 270 s->c = r;
1188 270 memcpy(s->block_state, state, sizeof(s->block_state));
1189 }
1190
1191
1/2
✓ Branch 0 taken 933 times.
✗ Branch 1 not taken.
 933 for(pass=0; pass<25; pass++){
1192 933 int change= 0;
1193
1194
2/2
✓ Branch 0 taken 3732 times.
✓ Branch 1 taken 933 times.
 4665 for(mb_y= 0; mb_y<b_height; mb_y++){
1195
2/2
✓ Branch 0 taken 29856 times.
✓ Branch 1 taken 3732 times.
 33588 for(mb_x= 0; mb_x<b_width; mb_x++){
1196 int dia_change, i, j, ref;
1197 29856 int best_rd= INT_MAX, ref_rd;
1198 BlockNode backup, ref_b;
1199 29856 const int index= mb_x + mb_y * b_stride;
1200 29856 BlockNode *block= &s->block[index];
1201
2/2
✓ Branch 0 taken 22392 times.
✓ Branch 1 taken 7464 times.
 29856 BlockNode *tb = mb_y ? &s->block[index-b_stride ] : NULL;
1202
2/2
✓ Branch 0 taken 26124 times.
✓ Branch 1 taken 3732 times.
 29856 BlockNode *lb = mb_x ? &s->block[index -1] : NULL;
1203
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;
1204
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;
1205
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;
1206
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;
1207
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;
1208
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;
1209 29856 const int b_w= (MB_SIZE >> s->block_max_depth);
1210 uint8_t obmc_edged[MB_SIZE * 2][MB_SIZE * 2];
1211
1212
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))
1213 11618 continue;
1214 18238 block->type |= BLOCK_OPT;
1215
1216 18238 backup= *block;
1217
1218
2/2
✓ Branch 0 taken 21 times.
✓ Branch 1 taken 18217 times.
 18238 if (!enc->me_cache_generation)
1219 21 memset(enc->me_cache, 0, sizeof(enc->me_cache));
1220 18238 enc->me_cache_generation += 1<<22;
1221
1222 //FIXME precalculate
1223 {
1224 int x, y;
1225
2/2
✓ Branch 0 taken 583616 times.
✓ Branch 1 taken 18238 times.
 601854 for (y = 0; y < b_w * 2; y++)
1226 583616 memcpy(obmc_edged[y], ff_obmc_tab[s->block_max_depth] + y * b_w * 2, b_w * 2);
1227
2/2
✓ Branch 0 taken 2241 times.
✓ Branch 1 taken 15997 times.
 18238 if(mb_x==0)
1228
2/2
✓ Branch 0 taken 71712 times.
✓ Branch 1 taken 2241 times.
 73953 for(y=0; y<b_w*2; y++)
1229 71712 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1230
2/2
✓ Branch 0 taken 1763 times.
✓ Branch 1 taken 16475 times.
 18238 if(mb_x==b_stride-1)
1231
2/2
✓ Branch 0 taken 56416 times.
✓ Branch 1 taken 1763 times.
 58179 for(y=0; y<b_w*2; y++)
1232 56416 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1233
2/2
✓ Branch 0 taken 4942 times.
✓ Branch 1 taken 13296 times.
 18238 if(mb_y==0){
1234
2/2
✓ Branch 0 taken 158144 times.
✓ Branch 1 taken 4942 times.
 163086 for(x=0; x<b_w*2; x++)
1235 158144 obmc_edged[0][x] += obmc_edged[b_w-1][x];
1236
2/2
✓ Branch 0 taken 74130 times.
✓ Branch 1 taken 4942 times.
 79072 for(y=1; y<b_w; y++)
1237 74130 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1238 }
1239
2/2
✓ Branch 0 taken 3492 times.
✓ Branch 1 taken 14746 times.
 18238 if(mb_y==b_height-1){
1240
2/2
✓ Branch 0 taken 111744 times.
✓ Branch 1 taken 3492 times.
 115236 for(x=0; x<b_w*2; x++)
1241 111744 obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1242
2/2
✓ Branch 0 taken 52380 times.
✓ Branch 1 taken 3492 times.
 55872 for(y=b_w; y<b_w*2-1; y++)
1243 52380 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1244 }
1245 }
1246
1247 //skip stuff outside the picture
1248
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){
1249 10627 const uint8_t *src = s->input_picture->data[0];
1250 10627 uint8_t *dst= s->current_picture->data[0];
1251 10627 const int stride= s->current_picture->linesize[0];
1252 10627 const int block_w= MB_SIZE >> s->block_max_depth;
1253 10627 const int block_h= MB_SIZE >> s->block_max_depth;
1254 10627 const int sx= block_w*mb_x - block_w/2;
1255 10627 const int sy= block_h*mb_y - block_h/2;
1256 10627 const int w= s->plane[0].width;
1257 10627 const int h= s->plane[0].height;
1258 int y;
1259
1260
2/2
✓ Branch 0 taken 39536 times.
✓ Branch 1 taken 10627 times.
 50163 for(y=sy; y<0; y++)
1261 39536 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1262
2/2
✓ Branch 0 taken 27936 times.
✓ Branch 1 taken 10627 times.
 38563 for(y=h; y<sy+block_h*2; y++)
1263 27936 memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1264
2/2
✓ Branch 0 taken 2241 times.
✓ Branch 1 taken 8386 times.
 10627 if(sx<0){
1265
2/2
✓ Branch 0 taken 71712 times.
✓ Branch 1 taken 2241 times.
 73953 for(y=sy; y<sy+block_h*2; y++)
1266 71712 memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1267 }
1268
2/2
✓ Branch 0 taken 1763 times.
✓ Branch 1 taken 8864 times.
 10627 if(sx+block_w*2 > w){
1269
2/2
✓ Branch 0 taken 56416 times.
✓ Branch 1 taken 1763 times.
 58179 for(y=sy; y<sy+block_h*2; y++)
1270 56416 memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1271 }
1272 }
1273
1274 // intra(black) = neighbors' contribution to the current block
1275
2/2
✓ Branch 0 taken 54714 times.
✓ Branch 1 taken 18238 times.
 72952 for(i=0; i < s->nb_planes; i++)
1276 54714 color[i]= get_dc(enc, mb_x, mb_y, i);
1277
1278 // get previous score (cannot be cached due to OBMC)
1279
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)){
1280 76 int color0[3]= {block->color[0], block->color[1], block->color[2]};
1281 76 check_block_intra(enc, mb_x, mb_y, color0, obmc_edged, &best_rd);
1282 }else
1283 18162 check_block_inter(enc, mb_x, mb_y, block->mx, block->my, obmc_edged, &best_rd);
1284
1285 18238 ref_b= *block;
1286 18238 ref_rd= best_rd;
1287
2/2
✓ Branch 0 taken 18238 times.
✓ Branch 1 taken 18238 times.
 36476 for(ref=0; ref < s->ref_frames; ref++){
1288 18238 int16_t (*mvr)[2]= &s->ref_mvs[ref][index];
1289
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
1290 ✗ continue;
1291 18238 block->ref= ref;
1292 18238 best_rd= INT_MAX;
1293
1294 18238 check_block_inter(enc, mb_x, mb_y, mvr[0][0], mvr[0][1], obmc_edged, &best_rd);
1295 18238 check_block_inter(enc, mb_x, mb_y, 0, 0, obmc_edged, &best_rd);
1296
2/2
✓ Branch 0 taken 13296 times.
✓ Branch 1 taken 4942 times.
 18238 if(tb)
1297 13296 check_block_inter(enc, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1298
2/2
✓ Branch 0 taken 15997 times.
✓ Branch 1 taken 2241 times.
 18238 if(lb)
1299 15997 check_block_inter(enc, mb_x, mb_y, mvr[-1][0], mvr[-1][1], obmc_edged, &best_rd);
1300
2/2
✓ Branch 0 taken 16475 times.
✓ Branch 1 taken 1763 times.
 18238 if(rb)
1301 16475 check_block_inter(enc, mb_x, mb_y, mvr[1][0], mvr[1][1], obmc_edged, &best_rd);
1302
2/2
✓ Branch 0 taken 14746 times.
✓ Branch 1 taken 3492 times.
 18238 if(bb)
1303 14746 check_block_inter(enc, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1304
1305 /* fullpel ME */
1306 //FIXME avoid subpel interpolation / round to nearest integer
1307 do{
1308 18658 int newx = block->mx;
1309 18658 int newy = block->my;
1310
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);
1311 18658 dia_change=0;
1312
2/2
✓ Branch 0 taken 37316 times.
✓ Branch 1 taken 18658 times.
 55974 for(i=0; i < dia_size; i++){
1313
2/2
✓ Branch 0 taken 18658 times.
✓ Branch 1 taken 37316 times.
 55974 for(j=0; j<i; j++){
1314 18658 dia_change |= check_block_inter(enc, mb_x, mb_y, newx+4*(i-j), newy+(4*j), obmc_edged, &best_rd);
1315 18658 dia_change |= check_block_inter(enc, mb_x, mb_y, newx-4*(i-j), newy-(4*j), obmc_edged, &best_rd);
1316 18658 dia_change |= check_block_inter(enc, mb_x, mb_y, newx-(4*j), newy+4*(i-j), obmc_edged, &best_rd);
1317 18658 dia_change |= check_block_inter(enc, mb_x, mb_y, newx+(4*j), newy-4*(i-j), obmc_edged, &best_rd);
1318 }
1319 }
1320
2/2
✓ Branch 0 taken 420 times.
✓ Branch 1 taken 18238 times.
 18658 }while(dia_change);
1321 /* subpel ME */
1322 do{
1323 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1324 26898 dia_change=0;
1325
2/2
✓ Branch 0 taken 215184 times.
✓ Branch 1 taken 26898 times.
 242082 for(i=0; i<8; i++)
1326 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);
1327
2/2
✓ Branch 0 taken 8660 times.
✓ Branch 1 taken 18238 times.
 26898 }while(dia_change);
1328 //FIXME or try the standard 2 pass qpel or similar
1329
1330 18238 mvr[0][0]= block->mx;
1331 18238 mvr[0][1]= block->my;
1332
2/2
✓ Branch 0 taken 4362 times.
✓ Branch 1 taken 13876 times.
 18238 if(ref_rd > best_rd){
1333 4362 ref_rd= best_rd;
1334 4362 ref_b= *block;
1335 }
1336 }
1337 18238 best_rd= ref_rd;
1338 18238 *block= ref_b;
1339 18238 check_block_intra(enc, mb_x, mb_y, color, obmc_edged, &best_rd);
1340 //FIXME RD style color selection
1341
2/2
✓ Branch 1 taken 4386 times.
✓ Branch 2 taken 13852 times.
 18238 if(!same_block(block, &backup)){
1342
2/2
✓ Branch 0 taken 3174 times.
✓ Branch 1 taken 1212 times.
 4386 if(tb ) tb ->type &= ~BLOCK_OPT;
1343
2/2
✓ Branch 0 taken 3853 times.
✓ Branch 1 taken 533 times.
 4386 if(lb ) lb ->type &= ~BLOCK_OPT;
1344
2/2
✓ Branch 0 taken 3892 times.
✓ Branch 1 taken 494 times.
 4386 if(rb ) rb ->type &= ~BLOCK_OPT;
1345
2/2
✓ Branch 0 taken 3458 times.
✓ Branch 1 taken 928 times.
 4386 if(bb ) bb ->type &= ~BLOCK_OPT;
1346
2/2
✓ Branch 0 taken 2772 times.
✓ Branch 1 taken 1614 times.
 4386 if(tlb) tlb->type &= ~BLOCK_OPT;
1347
2/2
✓ Branch 0 taken 2822 times.
✓ Branch 1 taken 1564 times.
 4386 if(trb) trb->type &= ~BLOCK_OPT;
1348
2/2
✓ Branch 0 taken 3031 times.
✓ Branch 1 taken 1355 times.
 4386 if(blb) blb->type &= ~BLOCK_OPT;
1349
2/2
✓ Branch 0 taken 3076 times.
✓ Branch 1 taken 1310 times.
 4386 if(brb) brb->type &= ~BLOCK_OPT;
1350 4386 change ++;
1351 }
1352 }
1353 }
1354 933 av_log(s->avctx, AV_LOG_DEBUG, "pass:%d changed:%d\n", pass, change);
1355
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 663 times.
 933 if(!change)
1356 270 break;
1357 }
1358
1359
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 270 times.
 270 if(s->block_max_depth == 1){
1360 ✗ int change= 0;
1361 ✗ for(mb_y= 0; mb_y<b_height; mb_y+=2){
1362 ✗ for(mb_x= 0; mb_x<b_width; mb_x+=2){
1363 int i;
1364 int best_rd, init_rd;
1365 ✗ const int index= mb_x + mb_y * b_stride;
1366 BlockNode *b[4];
1367
1368 ✗ b[0]= &s->block[index];
1369 ✗ b[1]= b[0]+1;
1370 ✗ b[2]= b[0]+b_stride;
1371 ✗ b[3]= b[2]+1;
1372 ✗ if(same_block(b[0], b[1]) &&
1373 ✗ same_block(b[0], b[2]) &&
1374 ✗ same_block(b[0], b[3]))
1375 ✗ continue;
1376
1377 ✗ if (!enc->me_cache_generation)
1378 ✗ memset(enc->me_cache, 0, sizeof(enc->me_cache));
1379 ✗ enc->me_cache_generation += 1<<22;
1380
1381 ✗ init_rd = best_rd = get_4block_rd(enc, mb_x, mb_y, 0);
1382
1383 //FIXME more multiref search?
1384 ✗ check_4block_inter(enc, mb_x, mb_y,
1385 ✗ (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
1386 ✗ (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
1387
1388 ✗ for(i=0; i<4; i++)
1389 ✗ if(!(b[i]->type&BLOCK_INTRA))
1390 ✗ check_4block_inter(enc, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);
1391
1392 ✗ if(init_rd != best_rd)
1393 ✗ change++;
1394 }
1395 }
1396 ✗ av_log(s->avctx, AV_LOG_ERROR, "pass:4mv changed:%d\n", change*4);
1397 }
1398 270 }
1399
1400 510 static void encode_blocks(SnowEncContext *enc, int search)
1401 {
1402 510 SnowContext *const s = &enc->com;
1403 int x, y;
1404 510 int w= s->b_width;
1405 510 int h= s->b_height;
1406
1407
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)
1408 270 iterative_me(enc);
1409
1410
2/2
✓ Branch 0 taken 6060 times.
✓ Branch 1 taken 510 times.
 6570 for(y=0; y<h; y++){
1411
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
1412 ✗ av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1413 ✗ return;
1414 }
1415
2/2
✓ Branch 0 taken 166200 times.
✓ Branch 1 taken 6060 times.
 172260 for(x=0; x<w; x++){
1416
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)
1417 9600 encode_q_branch2(s, 0, x, y);
1418 else
1419 156600 encode_q_branch (enc, 0, x, y);
1420 }
1421 }
1422 }
1423
1424 21600 static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias){
1425 21600 const int w= b->width;
1426 21600 const int h= b->height;
1427 21600 const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1428 21600 const int qmul= ff_qexp[qlog&(QROOT-1)]<<((qlog>>QSHIFT) + ENCODER_EXTRA_BITS);
1429 int x,y, thres1, thres2;
1430
1431
2/2
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 14400 times.
 21600 if(s->qlog == LOSSLESS_QLOG){
1432
2/2
✓ Branch 0 taken 253800 times.
✓ Branch 1 taken 7200 times.
 261000 for(y=0; y<h; y++)
1433
2/2
✓ Branch 0 taken 22809600 times.
✓ Branch 1 taken 253800 times.
 23063400 for(x=0; x<w; x++)
1434 22809600 dst[x + y*stride]= src[x + y*stride];
1435 7200 return;
1436 }
1437
1438
2/2
✓ Branch 0 taken 1440 times.
✓ Branch 1 taken 12960 times.
 14400 bias= bias ? 0 : (3*qmul)>>3;
1439 14400 thres1= ((qmul - bias)>>QEXPSHIFT) - 1;
1440 14400 thres2= 2*thres1;
1441
1442
2/2
✓ Branch 0 taken 12960 times.
✓ Branch 1 taken 1440 times.
 14400 if(!bias){
1443
2/2
✓ Branch 0 taken 101520 times.
✓ Branch 1 taken 12960 times.
 114480 for(y=0; y<h; y++){
1444
2/2
✓ Branch 0 taken 3317760 times.
✓ Branch 1 taken 101520 times.
 3419280 for(x=0; x<w; x++){
1445 3317760 int i= src[x + y*stride];
1446
1447
2/2
✓ Branch 0 taken 550371 times.
✓ Branch 1 taken 2767389 times.
 3317760 if((unsigned)(i+thres1) > thres2){
1448
2/2
✓ Branch 0 taken 275604 times.
✓ Branch 1 taken 274767 times.
 550371 if(i>=0){
1449 275604 i<<= QEXPSHIFT;
1450 275604 i/= qmul; //FIXME optimize
1451 275604 dst[x + y*stride]= i;
1452 }else{
1453 274767 i= -i;
1454 274767 i<<= QEXPSHIFT;
1455 274767 i/= qmul; //FIXME optimize
1456 274767 dst[x + y*stride]= -i;
1457 }
1458 }else
1459 2767389 dst[x + y*stride]= 0;
1460 }
1461 }
1462 }else{
1463
2/2
✓ Branch 0 taken 11280 times.
✓ Branch 1 taken 1440 times.
 12720 for(y=0; y<h; y++){
1464
2/2
✓ Branch 0 taken 368640 times.
✓ Branch 1 taken 11280 times.
 379920 for(x=0; x<w; x++){
1465 368640 int i= src[x + y*stride];
1466
1467
2/2
✓ Branch 0 taken 202458 times.
✓ Branch 1 taken 166182 times.
 368640 if((unsigned)(i+thres1) > thres2){
1468
2/2
✓ Branch 0 taken 101688 times.
✓ Branch 1 taken 100770 times.
 202458 if(i>=0){
1469 101688 i<<= QEXPSHIFT;
1470 101688 i= (i + bias) / qmul; //FIXME optimize
1471 101688 dst[x + y*stride]= i;
1472 }else{
1473 100770 i= -i;
1474 100770 i<<= QEXPSHIFT;
1475 100770 i= (i + bias) / qmul; //FIXME optimize
1476 100770 dst[x + y*stride]= -i;
1477 }
1478 }else
1479 166182 dst[x + y*stride]= 0;
1480 }
1481 }
1482 }
1483 }
1484
1485 21600 static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride){
1486 21600 const int w= b->width;
1487 21600 const int h= b->height;
1488 21600 const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1489 21600 const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1490 21600 const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1491 int x,y;
1492
1493
2/2
✓ Branch 0 taken 7200 times.
✓ Branch 1 taken 14400 times.
 21600 if(s->qlog == LOSSLESS_QLOG) return;
1494
1495
2/2
✓ Branch 0 taken 112800 times.
✓ Branch 1 taken 14400 times.
 127200 for(y=0; y<h; y++){
1496
2/2
✓ Branch 0 taken 3686400 times.
✓ Branch 1 taken 112800 times.
 3799200 for(x=0; x<w; x++){
1497 3686400 int i= src[x + y*stride];
1498
2/2
✓ Branch 0 taken 375500 times.
✓ Branch 1 taken 3310900 times.
 3686400 if(i<0){
1499 375500 src[x + y*stride]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
1500
2/2
✓ Branch 0 taken 377275 times.
✓ Branch 1 taken 2933625 times.
 3310900 }else if(i>0){
1501 377275 src[x + y*stride]= (( i*qmul + qadd)>>(QEXPSHIFT));
1502 }
1503 }
1504 }
1505 }
1506
1507 1350 static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1508 1350 const int w= b->width;
1509 1350 const int h= b->height;
1510 int x,y;
1511
1512
2/2
✓ Branch 0 taken 4050 times.
✓ Branch 1 taken 1350 times.
 5400 for(y=h-1; y>=0; y--){
1513
2/2
✓ Branch 0 taken 27450 times.
✓ Branch 1 taken 4050 times.
 31500 for(x=w-1; x>=0; x--){
1514 27450 int i= x + y*stride;
1515
1516
2/2
✓ Branch 0 taken 23400 times.
✓ Branch 1 taken 4050 times.
 27450 if(x){
1517
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23400 times.
 23400 if(use_median){
1518 ✗ if(y && x+1<w) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1519 ✗ else src[i] -= src[i - 1];
1520 }else{
1521
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]);
1522 4500 else src[i] -= src[i - 1];
1523 }
1524 }else{
1525
2/2
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 1350 times.
 4050 if(y) src[i] -= src[i - stride];
1526 }
1527 }
1528 }
1529 1350 }
1530
1531 1350 static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1532 1350 const int w= b->width;
1533 1350 const int h= b->height;
1534 int x,y;
1535
1536
2/2
✓ Branch 0 taken 4050 times.
✓ Branch 1 taken 1350 times.
 5400 for(y=0; y<h; y++){
1537
2/2
✓ Branch 0 taken 27450 times.
✓ Branch 1 taken 4050 times.
 31500 for(x=0; x<w; x++){
1538 27450 int i= x + y*stride;
1539
1540
2/2
✓ Branch 0 taken 23400 times.
✓ Branch 1 taken 4050 times.
 27450 if(x){
1541
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23400 times.
 23400 if(use_median){
1542 ✗ if(y && x+1<w) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1543 ✗ else src[i] += src[i - 1];
1544 }else{
1545
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]);
1546 4500 else src[i] += src[i - 1];
1547 }
1548 }else{
1549
2/2
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 1350 times.
 4050 if(y) src[i] += src[i - stride];
1550 }
1551 }
1552 }
1553 1350 }
1554
1555 47 static void encode_qlogs(SnowContext *s){
1556 int plane_index, level, orientation;
1557
1558
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++){
1559
2/2
✓ Branch 0 taken 470 times.
✓ Branch 1 taken 94 times.
 564 for(level=0; level<s->spatial_decomposition_count; level++){
1560
2/2
✓ Branch 0 taken 1504 times.
✓ Branch 1 taken 470 times.
 1974 for(orientation=level ? 1:0; orientation<4; orientation++){
1561
2/2
✓ Branch 0 taken 470 times.
✓ Branch 1 taken 1034 times.
 1504 if(orientation==2) continue;
1562 1034 put_symbol(&s->c, s->header_state, s->plane[plane_index].band[level][orientation].qlog, 1);
1563 }
1564 }
1565 }
1566 47 }
1567
1568 510 static void encode_header(SnowContext *s){
1569 int plane_index, i;
1570 uint8_t kstate[32];
1571
1572 510 memset(kstate, MID_STATE, sizeof(kstate));
1573
1574 510 put_rac(&s->c, kstate, s->keyframe);
1575
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){
1576 47 ff_snow_reset_contexts(s);
1577 47 s->last_spatial_decomposition_type=
1578 47 s->last_qlog=
1579 47 s->last_qbias=
1580 47 s->last_mv_scale=
1581 47 s->last_block_max_depth= 0;
1582
2/2
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 47 times.
 141 for(plane_index=0; plane_index<2; plane_index++){
1583 94 Plane *p= &s->plane[plane_index];
1584 94 p->last_htaps=0;
1585 94 p->last_diag_mc=0;
1586 94 memset(p->last_hcoeff, 0, sizeof(p->last_hcoeff));
1587 }
1588 }
1589
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 463 times.
 510 if(s->keyframe){
1590 47 put_symbol(&s->c, s->header_state, s->version, 0);
1591 47 put_rac(&s->c, s->header_state, s->always_reset);
1592 47 put_symbol(&s->c, s->header_state, s->temporal_decomposition_type, 0);
1593 47 put_symbol(&s->c, s->header_state, s->temporal_decomposition_count, 0);
1594 47 put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1595 47 put_symbol(&s->c, s->header_state, s->colorspace_type, 0);
1596
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
 47 if (s->nb_planes > 2) {
1597 47 put_symbol(&s->c, s->header_state, s->chroma_h_shift, 0);
1598 47 put_symbol(&s->c, s->header_state, s->chroma_v_shift, 0);
1599 }
1600 47 put_rac(&s->c, s->header_state, s->spatial_scalability);
1601 // put_rac(&s->c, s->header_state, s->rate_scalability);
1602 47 put_symbol(&s->c, s->header_state, s->max_ref_frames-1, 0);
1603
1604 47 encode_qlogs(s);
1605 }
1606
1607
2/2
✓ Branch 0 taken 463 times.
✓ Branch 1 taken 47 times.
 510 if(!s->keyframe){
1608 463 int update_mc=0;
1609
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++){
1610 926 Plane *p= &s->plane[plane_index];
1611 926 update_mc |= p->last_htaps != p->htaps;
1612 926 update_mc |= p->last_diag_mc != p->diag_mc;
1613 926 update_mc |= !!memcmp(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1614 }
1615 463 put_rac(&s->c, s->header_state, update_mc);
1616
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 416 times.
 463 if(update_mc){
1617
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++){
1618 94 Plane *p= &s->plane[plane_index];
1619 94 put_rac(&s->c, s->header_state, p->diag_mc);
1620 94 put_symbol(&s->c, s->header_state, p->htaps/2-1, 0);
1621
2/2
✓ Branch 0 taken 282 times.
✓ Branch 1 taken 94 times.
 376 for(i= p->htaps/2; i; i--)
1622 282 put_symbol(&s->c, s->header_state, FFABS(p->hcoeff[i]), 0);
1623 }
1624 }
1625
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 463 times.
 463 if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1626 ✗ put_rac(&s->c, s->header_state, 1);
1627 ✗ put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1628 ✗ encode_qlogs(s);
1629 }else
1630 463 put_rac(&s->c, s->header_state, 0);
1631 }
1632
1633 510 put_symbol(&s->c, s->header_state, s->spatial_decomposition_type - s->last_spatial_decomposition_type, 1);
1634 510 put_symbol(&s->c, s->header_state, s->qlog - s->last_qlog , 1);
1635 510 put_symbol(&s->c, s->header_state, s->mv_scale - s->last_mv_scale, 1);
1636 510 put_symbol(&s->c, s->header_state, s->qbias - s->last_qbias , 1);
1637 510 put_symbol(&s->c, s->header_state, s->block_max_depth - s->last_block_max_depth, 1);
1638
1639 510 }
1640
1641 510 static void update_last_header_values(SnowContext *s){
1642 int plane_index;
1643
1644
2/2
✓ Branch 0 taken 463 times.
✓ Branch 1 taken 47 times.
 510 if(!s->keyframe){
1645
2/2
✓ Branch 0 taken 926 times.
✓ Branch 1 taken 463 times.
 1389 for(plane_index=0; plane_index<2; plane_index++){
1646 926 Plane *p= &s->plane[plane_index];
1647 926 p->last_diag_mc= p->diag_mc;
1648 926 p->last_htaps = p->htaps;
1649 926 memcpy(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1650 }
1651 }
1652
1653 510 s->last_spatial_decomposition_type = s->spatial_decomposition_type;
1654 510 s->last_qlog = s->qlog;
1655 510 s->last_qbias = s->qbias;
1656 510 s->last_mv_scale = s->mv_scale;
1657 510 s->last_block_max_depth = s->block_max_depth;
1658 510 s->last_spatial_decomposition_count = s->spatial_decomposition_count;
1659 510 }
1660
1661 360 static int qscale2qlog(int qscale){
1662 360 return lrint(QROOT*log2(qscale / (float)FF_QP2LAMBDA))
1663 360 + 61*QROOT/8; ///< 64 > 60
1664 }
1665
1666 ✗ static int ratecontrol_1pass(SnowEncContext *enc, AVFrame *pict)
1667 {
1668 ✗ SnowContext *const s = &enc->com;
1669 /* Estimate the frame's complexity as a sum of weighted dwt coefficients.
1670 * FIXME we know exact mv bits at this point,
1671 * but ratecontrol isn't set up to include them. */
1672 ✗ uint32_t coef_sum= 0;
1673 int level, orientation, delta_qlog;
1674
1675 ✗ for(level=0; level<s->spatial_decomposition_count; level++){
1676 ✗ for(orientation=level ? 1 : 0; orientation<4; orientation++){
1677 ✗ SubBand *b= &s->plane[0].band[level][orientation];
1678 ✗ IDWTELEM *buf= b->ibuf;
1679 ✗ const int w= b->width;
1680 ✗ const int h= b->height;
1681 ✗ const int stride= b->stride;
1682 ✗ const int qlog= av_clip(2*QROOT + b->qlog, 0, QROOT*16);
1683 ✗ const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1684 ✗ const int qdiv= (1<<16)/qmul;
1685 int x, y;
1686 //FIXME this is ugly
1687 ✗ for(y=0; y<h; y++)
1688 ✗ for(x=0; x<w; x++)
1689 ✗ buf[x+y*stride]= b->buf[x+y*stride];
1690 ✗ if(orientation==0)
1691 ✗ decorrelate(s, b, buf, stride, 1, 0);
1692 ✗ for(y=0; y<h; y++)
1693 ✗ for(x=0; x<w; x++)
1694 ✗ coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1695 }
1696 }
1697
1698 /* ugly, ratecontrol just takes a sqrt again */
1699 ✗ av_assert0(coef_sum < INT_MAX);
1700 ✗ coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1701
1702 ✗ if(pict->pict_type == AV_PICTURE_TYPE_I){
1703 ✗ enc->m.mb_var_sum = coef_sum;
1704 ✗ enc->m.mc_mb_var_sum = 0;
1705 }else{
1706 ✗ enc->m.mc_mb_var_sum = coef_sum;
1707 ✗ enc->m.mb_var_sum = 0;
1708 }
1709
1710 ✗ pict->quality= ff_rate_estimate_qscale(&enc->m, 1);
1711 ✗ if (pict->quality < 0)
1712 ✗ return INT_MIN;
1713 ✗ enc->lambda= pict->quality * 3/2;
1714 ✗ delta_qlog= qscale2qlog(pict->quality) - s->qlog;
1715 ✗ s->qlog+= delta_qlog;
1716 ✗ return delta_qlog;
1717 }
1718
1719 33 static void calculate_visual_weight(SnowContext *s, Plane *p){
1720 33 int width = p->width;
1721 33 int height= p->height;
1722 int level, orientation, x, y;
1723
1724
2/2
✓ Branch 0 taken 165 times.
✓ Branch 1 taken 33 times.
 198 for(level=0; level<s->spatial_decomposition_count; level++){
1725 165 int64_t error=0;
1726
2/2
✓ Branch 0 taken 528 times.
✓ Branch 1 taken 165 times.
 693 for(orientation=level ? 1 : 0; orientation<4; orientation++){
1727 528 SubBand *b= &p->band[level][orientation];
1728 528 IDWTELEM *ibuf= b->ibuf;
1729
1730 528 memset(s->spatial_idwt_buffer, 0, sizeof(*s->spatial_idwt_buffer)*width*height);
1731 528 ibuf[b->width/2 + b->height/2*b->stride]= 256*16;
1732 528 ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, width, height, width, s->spatial_decomposition_type, s->spatial_decomposition_count);
1733
2/2
✓ Branch 0 taken 76800 times.
✓ Branch 1 taken 528 times.
 77328 for(y=0; y<height; y++){
1734
2/2
✓ Branch 0 taken 28385280 times.
✓ Branch 1 taken 76800 times.
 28462080 for(x=0; x<width; x++){
1735 28385280 int64_t d= s->spatial_idwt_buffer[x + y*width]*16;
1736 28385280 error += d*d;
1737 }
1738 }
1739
2/2
✓ Branch 0 taken 165 times.
✓ Branch 1 taken 363 times.
 528 if (orientation == 2)
1740 165 error /= 2;
1741 528 b->qlog= (int)(QROOT * log2(352256.0/sqrt(error)) + 0.5);
1742
2/2
✓ Branch 0 taken 363 times.
✓ Branch 1 taken 165 times.
 528 if (orientation != 1)
1743 363 error = 0;
1744 }
1745 165 p->band[level][1].qlog = p->band[level][2].qlog;
1746 }
1747 33 }
1748
1749 510 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1750 const AVFrame *pict, int *got_packet)
1751 {
1752 510 SnowEncContext *const enc = avctx->priv_data;
1753 510 SnowContext *const s = &enc->com;
1754 510 MpegEncContext *const mpv = &enc->m;
1755 510 RangeCoder * const c= &s->c;
1756 510 AVCodecInternal *avci = avctx->internal;
1757 AVFrame *pic;
1758 510 const int width= s->avctx->width;
1759 510 const int height= s->avctx->height;
1760 int level, orientation, plane_index, i, y, ret;
1761 uint8_t rc_header_bak[sizeof(s->header_state)];
1762 uint8_t rc_block_bak[sizeof(s->block_state)];
1763
1764
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 + AV_INPUT_BUFFER_MIN_SIZE)) < 0)
1765 ✗ return ret;
1766
1767 510 ff_init_range_encoder(c, pkt->data, pkt->size);
1768 510 ff_build_rac_states(c, (1LL<<32)/20, 256-8);
1769
1770
2/2
✓ Branch 0 taken 1530 times.
✓ Branch 1 taken 510 times.
 2040 for(i=0; i < s->nb_planes; i++){
1771
2/2
✓ Branch 0 taken 1020 times.
✓ Branch 1 taken 510 times.
 1530 int hshift= i ? s->chroma_h_shift : 0;
1772
2/2
✓ Branch 0 taken 1020 times.
✓ Branch 1 taken 510 times.
 1530 int vshift= i ? s->chroma_v_shift : 0;
1773
2/2
✓ Branch 0 taken 193920 times.
✓ Branch 1 taken 1530 times.
 195450 for(y=0; y<AV_CEIL_RSHIFT(height, vshift); y++)
1774 193920 memcpy(&s->input_picture->data[i][y * s->input_picture->linesize[i]],
1775 193920