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