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