← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/snow.h

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:23:28 UTC
  • mfrom: (0.4.7 sid)
  • mto: This revision was merged to the branch mainline in revision 76.
  • Revision ID: package-import@ubuntu.com-20120112222328-8jqdyodym3p84ygu
Tags: 2:1.0~rc4.dfsg1+svn34540-1
* New upstream snapshot
* upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/snow.h
25
25
#include "dsputil.h"
26
26
#include "dwt.h"
27
27
 
 
28
#include "rangecoder.h"
 
29
#include "mathops.h"
 
30
#include "mpegvideo.h"
 
31
 
28
32
#define MID_STATE 128
29
33
 
30
34
#define MAX_PLANES 4
36
40
 
37
41
#define LOG2_OBMC_MAX 8
38
42
#define OBMC_MAX (1<<(LOG2_OBMC_MAX))
 
43
typedef struct BlockNode{
 
44
    int16_t mx;
 
45
    int16_t my;
 
46
    uint8_t ref;
 
47
    uint8_t color[3];
 
48
    uint8_t type;
 
49
//#define TYPE_SPLIT    1
 
50
#define BLOCK_INTRA   1
 
51
#define BLOCK_OPT     2
 
52
//#define TYPE_NOCOLOR  4
 
53
    uint8_t level; //FIXME merge into type?
 
54
}BlockNode;
 
55
 
 
56
static const BlockNode null_block= { //FIXME add border maybe
 
57
    .color= {128,128,128},
 
58
    .mx= 0,
 
59
    .my= 0,
 
60
    .ref= 0,
 
61
    .type= 0,
 
62
    .level= 0,
 
63
};
 
64
 
 
65
#define LOG2_MB_SIZE 4
 
66
#define MB_SIZE (1<<LOG2_MB_SIZE)
 
67
#define ENCODER_EXTRA_BITS 4
 
68
#define HTAPS_MAX 8
 
69
 
 
70
typedef struct x_and_coeff{
 
71
    int16_t x;
 
72
    uint16_t coeff;
 
73
} x_and_coeff;
 
74
 
 
75
typedef struct SubBand{
 
76
    int level;
 
77
    int stride;
 
78
    int width;
 
79
    int height;
 
80
    int qlog;        ///< log(qscale)/log[2^(1/6)]
 
81
    DWTELEM *buf;
 
82
    IDWTELEM *ibuf;
 
83
    int buf_x_offset;
 
84
    int buf_y_offset;
 
85
    int stride_line; ///< Stride measured in lines, not pixels.
 
86
    x_and_coeff * x_coeff;
 
87
    struct SubBand *parent;
 
88
    uint8_t state[/*7*2*/ 7 + 512][32];
 
89
}SubBand;
 
90
 
 
91
typedef struct Plane{
 
92
    int width;
 
93
    int height;
 
94
    SubBand band[MAX_DECOMPOSITIONS][4];
 
95
 
 
96
    int htaps;
 
97
    int8_t hcoeff[HTAPS_MAX/2];
 
98
    int diag_mc;
 
99
    int fast_mc;
 
100
 
 
101
    int last_htaps;
 
102
    int8_t last_hcoeff[HTAPS_MAX/2];
 
103
    int last_diag_mc;
 
104
}Plane;
 
105
 
 
106
typedef struct SnowContext{
 
107
    AVClass *class;
 
108
    AVCodecContext *avctx;
 
109
    RangeCoder c;
 
110
    DSPContext dsp;
 
111
    DWTContext dwt;
 
112
    AVFrame new_picture;
 
113
    AVFrame input_picture;              ///< new_picture with the internal linesizes
 
114
    AVFrame current_picture;
 
115
    AVFrame last_picture[MAX_REF_FRAMES];
 
116
    uint8_t *halfpel_plane[MAX_REF_FRAMES][4][4];
 
117
    AVFrame mconly_picture;
 
118
//     uint8_t q_context[16];
 
119
    uint8_t header_state[32];
 
120
    uint8_t block_state[128 + 32*128];
 
121
    int keyframe;
 
122
    int always_reset;
 
123
    int version;
 
124
    int spatial_decomposition_type;
 
125
    int last_spatial_decomposition_type;
 
126
    int temporal_decomposition_type;
 
127
    int spatial_decomposition_count;
 
128
    int last_spatial_decomposition_count;
 
129
    int temporal_decomposition_count;
 
130
    int max_ref_frames;
 
131
    int ref_frames;
 
132
    int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
 
133
    uint32_t *ref_scores[MAX_REF_FRAMES];
 
134
    DWTELEM *spatial_dwt_buffer;
 
135
    IDWTELEM *spatial_idwt_buffer;
 
136
    int colorspace_type;
 
137
    int chroma_h_shift;
 
138
    int chroma_v_shift;
 
139
    int spatial_scalability;
 
140
    int qlog;
 
141
    int last_qlog;
 
142
    int lambda;
 
143
    int lambda2;
 
144
    int pass1_rc;
 
145
    int mv_scale;
 
146
    int last_mv_scale;
 
147
    int qbias;
 
148
    int last_qbias;
 
149
#define QBIAS_SHIFT 3
 
150
    int b_width;
 
151
    int b_height;
 
152
    int block_max_depth;
 
153
    int last_block_max_depth;
 
154
    Plane plane[MAX_PLANES];
 
155
    BlockNode *block;
 
156
#define ME_CACHE_SIZE 1024
 
157
    unsigned me_cache[ME_CACHE_SIZE];
 
158
    unsigned me_cache_generation;
 
159
    slice_buffer sb;
 
160
    int memc_only;
 
161
 
 
162
    MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
 
163
 
 
164
    uint8_t *scratchbuf;
 
165
}SnowContext;
 
166
 
 
167
/* Tables */
 
168
extern const uint8_t * const obmc_tab[4];
 
169
#ifdef __sgi
 
170
// Avoid a name clash on SGI IRIX
 
171
#undef qexp
 
172
#endif
 
173
extern uint8_t qexp[QROOT];
 
174
extern int scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES];
39
175
 
40
176
/* C bits used by mmx/sse2/altivec */
41
177
 
75
211
        }
76
212
}
77
213
 
 
214
/* common code */
 
215
 
 
216
int ff_snow_common_init(AVCodecContext *avctx);
 
217
int ff_snow_common_init_after_header(AVCodecContext *avctx);
 
218
void ff_snow_common_end(SnowContext *s);
 
219
void ff_snow_release_buffer(AVCodecContext *avctx);
 
220
void ff_snow_reset_contexts(SnowContext *s);
 
221
int ff_snow_alloc_blocks(SnowContext *s);
 
222
int ff_snow_frame_start(SnowContext *s);
 
223
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride,
 
224
                     int sx, int sy, int b_w, int b_h, BlockNode *block,
 
225
                     int plane_index, int w, int h);
 
226
/* common inline functions */
 
227
//XXX doublecheck all of them should stay inlined
 
228
 
 
229
static inline void snow_set_blocks(SnowContext *s, int level, int x, int y, int l, int cb, int cr, int mx, int my, int ref, int type){
 
230
    const int w= s->b_width << s->block_max_depth;
 
231
    const int rem_depth= s->block_max_depth - level;
 
232
    const int index= (x + y*w) << rem_depth;
 
233
    const int block_w= 1<<rem_depth;
 
234
    BlockNode block;
 
235
    int i,j;
 
236
 
 
237
    block.color[0]= l;
 
238
    block.color[1]= cb;
 
239
    block.color[2]= cr;
 
240
    block.mx= mx;
 
241
    block.my= my;
 
242
    block.ref= ref;
 
243
    block.type= type;
 
244
    block.level= level;
 
245
 
 
246
    for(j=0; j<block_w; j++){
 
247
        for(i=0; i<block_w; i++){
 
248
            s->block[index + i + j*w]= block;
 
249
        }
 
250
    }
 
251
}
 
252
 
 
253
static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
 
254
                           const BlockNode *left, const BlockNode *top, const BlockNode *tr){
 
255
    if(s->ref_frames == 1){
 
256
        *mx = mid_pred(left->mx, top->mx, tr->mx);
 
257
        *my = mid_pred(left->my, top->my, tr->my);
 
258
    }else{
 
259
        const int *scale = scale_mv_ref[ref];
 
260
        *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
 
261
                       (top ->mx * scale[top ->ref] + 128) >>8,
 
262
                       (tr  ->mx * scale[tr  ->ref] + 128) >>8);
 
263
        *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
 
264
                       (top ->my * scale[top ->ref] + 128) >>8,
 
265
                       (tr  ->my * scale[tr  ->ref] + 128) >>8);
 
266
    }
 
267
}
 
268
 
 
269
static av_always_inline int same_block(BlockNode *a, BlockNode *b){
 
270
    if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
 
271
        return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
 
272
    }else{
 
273
        return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
 
274
    }
 
275
}
 
276
 
 
277
//FIXME name cleanup (b_w, block_w, b_width stuff)
 
278
//XXX should we really inline it?
 
279
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){
 
280
    const int b_width = s->b_width  << s->block_max_depth;
 
281
    const int b_height= s->b_height << s->block_max_depth;
 
282
    const int b_stride= b_width;
 
283
    BlockNode *lt= &s->block[b_x + b_y*b_stride];
 
284
    BlockNode *rt= lt+1;
 
285
    BlockNode *lb= lt+b_stride;
 
286
    BlockNode *rb= lb+1;
 
287
    uint8_t *block[4];
 
288
    int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
 
289
    uint8_t *tmp = s->scratchbuf;
 
290
    uint8_t *ptmp;
 
291
    int x,y;
 
292
 
 
293
    if(b_x<0){
 
294
        lt= rt;
 
295
        lb= rb;
 
296
    }else if(b_x + 1 >= b_width){
 
297
        rt= lt;
 
298
        rb= lb;
 
299
    }
 
300
    if(b_y<0){
 
301
        lt= lb;
 
302
        rt= rb;
 
303
    }else if(b_y + 1 >= b_height){
 
304
        lb= lt;
 
305
        rb= rt;
 
306
    }
 
307
 
 
308
    if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
 
309
        obmc -= src_x;
 
310
        b_w += src_x;
 
311
        if(!sliced && !offset_dst)
 
312
            dst -= src_x;
 
313
        src_x=0;
 
314
    }else if(src_x + b_w > w){
 
315
        b_w = w - src_x;
 
316
    }
 
317
    if(src_y<0){
 
318
        obmc -= src_y*obmc_stride;
 
319
        b_h += src_y;
 
320
        if(!sliced && !offset_dst)
 
321
            dst -= src_y*dst_stride;
 
322
        src_y=0;
 
323
    }else if(src_y + b_h> h){
 
324
        b_h = h - src_y;
 
325
    }
 
326
 
 
327
    if(b_w<=0 || b_h<=0) return;
 
328
 
 
329
    assert(src_stride > 2*MB_SIZE + 5);
 
330
 
 
331
    if(!sliced && offset_dst)
 
332
        dst += src_x + src_y*dst_stride;
 
333
    dst8+= src_x + src_y*src_stride;
 
334
//    src += src_x + src_y*src_stride;
 
335
 
 
336
    ptmp= tmp + 3*tmp_step;
 
337
    block[0]= ptmp;
 
338
    ptmp+=tmp_step;
 
339
    ff_snow_pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
 
340
 
 
341
    if(same_block(lt, rt)){
 
342
        block[1]= block[0];
 
343
    }else{
 
344
        block[1]= ptmp;
 
345
        ptmp+=tmp_step;
 
346
        ff_snow_pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
 
347
    }
 
348
 
 
349
    if(same_block(lt, lb)){
 
350
        block[2]= block[0];
 
351
    }else if(same_block(rt, lb)){
 
352
        block[2]= block[1];
 
353
    }else{
 
354
        block[2]= ptmp;
 
355
        ptmp+=tmp_step;
 
356
        ff_snow_pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
 
357
    }
 
358
 
 
359
    if(same_block(lt, rb) ){
 
360
        block[3]= block[0];
 
361
    }else if(same_block(rt, rb)){
 
362
        block[3]= block[1];
 
363
    }else if(same_block(lb, rb)){
 
364
        block[3]= block[2];
 
365
    }else{
 
366
        block[3]= ptmp;
 
367
        ff_snow_pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
 
368
    }
 
369
    if(sliced){
 
370
        s->dwt.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
 
371
    }else{
 
372
        for(y=0; y<b_h; y++){
 
373
            //FIXME ugly misuse of obmc_stride
 
374
            const uint8_t *obmc1= obmc + y*obmc_stride;
 
375
            const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
 
376
            const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
 
377
            const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
 
378
            for(x=0; x<b_w; x++){
 
379
                int v=   obmc1[x] * block[3][x + y*src_stride]
 
380
                        +obmc2[x] * block[2][x + y*src_stride]
 
381
                        +obmc3[x] * block[1][x + y*src_stride]
 
382
                        +obmc4[x] * block[0][x + y*src_stride];
 
383
 
 
384
                v <<= 8 - LOG2_OBMC_MAX;
 
385
                if(FRAC_BITS != 8){
 
386
                    v >>= 8 - FRAC_BITS;
 
387
                }
 
388
                if(add){
 
389
                    v += dst[x + y*dst_stride];
 
390
                    v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
 
391
                    if(v&(~255)) v= ~(v>>31);
 
392
                    dst8[x + y*src_stride] = v;
 
393
                }else{
 
394
                    dst[x + y*dst_stride] -= v;
 
395
                }
 
396
            }
 
397
        }
 
398
    }
 
399
}
 
400
 
 
401
static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
 
402
    Plane *p= &s->plane[plane_index];
 
403
    const int mb_w= s->b_width  << s->block_max_depth;
 
404
    const int mb_h= s->b_height << s->block_max_depth;
 
405
    int x, y, mb_x;
 
406
    int block_size = MB_SIZE >> s->block_max_depth;
 
407
    int block_w    = plane_index ? block_size/2 : block_size;
 
408
    const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
 
409
    const int obmc_stride= plane_index ? block_size : 2*block_size;
 
410
    int ref_stride= s->current_picture.linesize[plane_index];
 
411
    uint8_t *dst8= s->current_picture.data[plane_index];
 
412
    int w= p->width;
 
413
    int h= p->height;
 
414
 
 
415
    if(s->keyframe || (s->avctx->debug&512)){
 
416
        if(mb_y==mb_h)
 
417
            return;
 
418
 
 
419
        if(add){
 
420
            for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
 
421
                for(x=0; x<w; x++){
 
422
                    int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
 
423
                    v >>= FRAC_BITS;
 
424
                    if(v&(~255)) v= ~(v>>31);
 
425
                    dst8[x + y*ref_stride]= v;
 
426
                }
 
427
            }
 
428
        }else{
 
429
            for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
 
430
                for(x=0; x<w; x++){
 
431
                    buf[x + y*w]-= 128<<FRAC_BITS;
 
432
                }
 
433
            }
 
434
        }
 
435
 
 
436
        return;
 
437
    }
 
438
 
 
439
    for(mb_x=0; mb_x<=mb_w; mb_x++){
 
440
        add_yblock(s, 0, NULL, buf, dst8, obmc,
 
441
                   block_w*mb_x - block_w/2,
 
442
                   block_w*mb_y - block_w/2,
 
443
                   block_w, block_w,
 
444
                   w, h,
 
445
                   w, ref_stride, obmc_stride,
 
446
                   mb_x - 1, mb_y - 1,
 
447
                   add, 1, plane_index);
 
448
    }
 
449
}
 
450
 
 
451
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
 
452
    const int mb_h= s->b_height << s->block_max_depth;
 
453
    int mb_y;
 
454
    for(mb_y=0; mb_y<=mb_h; mb_y++)
 
455
        predict_slice(s, buf, plane_index, add, mb_y);
 
456
}
 
457
 
 
458
static inline 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){
 
459
    const int w= s->b_width << s->block_max_depth;
 
460
    const int rem_depth= s->block_max_depth - level;
 
461
    const int index= (x + y*w) << rem_depth;
 
462
    const int block_w= 1<<rem_depth;
 
463
    BlockNode block;
 
464
    int i,j;
 
465
 
 
466
    block.color[0]= l;
 
467
    block.color[1]= cb;
 
468
    block.color[2]= cr;
 
469
    block.mx= mx;
 
470
    block.my= my;
 
471
    block.ref= ref;
 
472
    block.type= type;
 
473
    block.level= level;
 
474
 
 
475
    for(j=0; j<block_w; j++){
 
476
        for(i=0; i<block_w; i++){
 
477
            s->block[index + i + j*w]= block;
 
478
        }
 
479
    }
 
480
}
 
481
 
 
482
static inline void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index){
 
483
    const int offset[3]= {
 
484
          y*c->  stride + x,
 
485
        ((y*c->uvstride + x)>>1),
 
486
        ((y*c->uvstride + x)>>1),
 
487
    };
 
488
    int i;
 
489
    for(i=0; i<3; i++){
 
490
        c->src[0][i]= src [i];
 
491
        c->ref[0][i]= ref [i] + offset[i];
 
492
    }
 
493
    assert(!ref_index);
 
494
}
 
495
 
 
496
 
 
497
/* bitstream functions */
 
498
 
 
499
extern const int8_t quant3bA[256];
 
500
 
 
501
#define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
 
502
 
 
503
static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
 
504
    int i;
 
505
 
 
506
    if(v){
 
507
        const int a= FFABS(v);
 
508
        const int e= av_log2(a);
 
509
        const int el= FFMIN(e, 10);
 
510
        put_rac(c, state+0, 0);
 
511
 
 
512
        for(i=0; i<el; i++){
 
513
            put_rac(c, state+1+i, 1);  //1..10
 
514
        }
 
515
        for(; i<e; i++){
 
516
            put_rac(c, state+1+9, 1);  //1..10
 
517
        }
 
518
        put_rac(c, state+1+FFMIN(i,9), 0);
 
519
 
 
520
        for(i=e-1; i>=el; i--){
 
521
            put_rac(c, state+22+9, (a>>i)&1); //22..31
 
522
        }
 
523
        for(; i>=0; i--){
 
524
            put_rac(c, state+22+i, (a>>i)&1); //22..31
 
525
        }
 
526
 
 
527
        if(is_signed)
 
528
            put_rac(c, state+11 + el, v < 0); //11..21
 
529
    }else{
 
530
        put_rac(c, state+0, 1);
 
531
    }
 
532
}
 
533
 
 
534
static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
 
535
    if(get_rac(c, state+0))
 
536
        return 0;
 
537
    else{
 
538
        int i, e, a;
 
539
        e= 0;
 
540
        while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
 
541
            e++;
 
542
        }
 
543
 
 
544
        a= 1;
 
545
        for(i=e-1; i>=0; i--){
 
546
            a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
 
547
        }
 
548
 
 
549
        e= -(is_signed && get_rac(c, state+11 + FFMIN(e,10))); //11..21
 
550
        return (a^e)-e;
 
551
    }
 
552
}
 
553
 
 
554
static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
 
555
    int i;
 
556
    int r= log2>=0 ? 1<<log2 : 1;
 
557
 
 
558
    assert(v>=0);
 
559
    assert(log2>=-4);
 
560
 
 
561
    while(v >= r){
 
562
        put_rac(c, state+4+log2, 1);
 
563
        v -= r;
 
564
        log2++;
 
565
        if(log2>0) r+=r;
 
566
    }
 
567
    put_rac(c, state+4+log2, 0);
 
568
 
 
569
    for(i=log2-1; i>=0; i--){
 
570
        put_rac(c, state+31-i, (v>>i)&1);
 
571
    }
 
572
}
 
573
 
 
574
static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
 
575
    int i;
 
576
    int r= log2>=0 ? 1<<log2 : 1;
 
577
    int v=0;
 
578
 
 
579
    assert(log2>=-4);
 
580
 
 
581
    while(get_rac(c, state+4+log2)){
 
582
        v+= r;
 
583
        log2++;
 
584
        if(log2>0) r+=r;
 
585
    }
 
586
 
 
587
    for(i=log2-1; i>=0; i--){
 
588
        v+= get_rac(c, state+31-i)<<i;
 
589
    }
 
590
 
 
591
    return v;
 
592
}
 
593
 
 
594
static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
 
595
    const int w= b->width;
 
596
    const int h= b->height;
 
597
    int x,y;
 
598
 
 
599
    int run, runs;
 
600
    x_and_coeff *xc= b->x_coeff;
 
601
    x_and_coeff *prev_xc= NULL;
 
602
    x_and_coeff *prev2_xc= xc;
 
603
    x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
 
604
    x_and_coeff *prev_parent_xc= parent_xc;
 
605
 
 
606
    runs= get_symbol2(&s->c, b->state[30], 0);
 
607
    if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
 
608
    else           run= INT_MAX;
 
609
 
 
610
    for(y=0; y<h; y++){
 
611
        int v=0;
 
612
        int lt=0, t=0, rt=0;
 
613
 
 
614
        if(y && prev_xc->x == 0){
 
615
            rt= prev_xc->coeff;
 
616
        }
 
617
        for(x=0; x<w; x++){
 
618
            int p=0;
 
619
            const int l= v;
 
620
 
 
621
            lt= t; t= rt;
 
622
 
 
623
            if(y){
 
624
                if(prev_xc->x <= x)
 
625
                    prev_xc++;
 
626
                if(prev_xc->x == x + 1)
 
627
                    rt= prev_xc->coeff;
 
628
                else
 
629
                    rt=0;
 
630
            }
 
631
            if(parent_xc){
 
632
                if(x>>1 > parent_xc->x){
 
633
                    parent_xc++;
 
634
                }
 
635
                if(x>>1 == parent_xc->x){
 
636
                    p= parent_xc->coeff;
 
637
                }
 
638
            }
 
639
            if(/*ll|*/l|lt|t|rt|p){
 
640
                int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
 
641
 
 
642
                v=get_rac(&s->c, &b->state[0][context]);
 
643
                if(v){
 
644
                    v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
 
645
                    v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l&0xFF] + 3*quant3bA[t&0xFF]]);
 
646
 
 
647
                    xc->x=x;
 
648
                    (xc++)->coeff= v;
 
649
                }
 
650
            }else{
 
651
                if(!run){
 
652
                    if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
 
653
                    else           run= INT_MAX;
 
654
                    v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
 
655
                    v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
 
656
 
 
657
                    xc->x=x;
 
658
                    (xc++)->coeff= v;
 
659
                }else{
 
660
                    int max_run;
 
661
                    run--;
 
662
                    v=0;
 
663
 
 
664
                    if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
 
665
                    else  max_run= FFMIN(run, w-x-1);
 
666
                    if(parent_xc)
 
667
                        max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
 
668
                    x+= max_run;
 
669
                    run-= max_run;
 
670
                }
 
671
            }
 
672
        }
 
673
        (xc++)->x= w+1; //end marker
 
674
        prev_xc= prev2_xc;
 
675
        prev2_xc= xc;
 
676
 
 
677
        if(parent_xc){
 
678
            if(y&1){
 
679
                while(parent_xc->x != parent->width+1)
 
680
                    parent_xc++;
 
681
                parent_xc++;
 
682
                prev_parent_xc= parent_xc;
 
683
            }else{
 
684
                parent_xc= prev_parent_xc;
 
685
            }
 
686
        }
 
687
    }
 
688
 
 
689
    (xc++)->x= w+1; //end marker
 
690
}
 
691
 
78
692
#endif /* AVCODEC_SNOW_H */