Statistics
| Branch: | Revision:

ffmpeg / libavcodec / wmv2.c @ 983e3246

History | View | Annotate | Download (24.4 KB)

1
/*
2
 * Copyright (c) 2002 The FFmpeg Project.
3
 *
4
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2 of the License, or (at your option) any later version.
8
 *
9
 * This library is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with this library; if not, write to the Free Software
16
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 *
18
 */
19

    
20
/**
21
 * @file wmv2.c
22
 * wmv2 codec.
23
 */
24
 
25
#include "simple_idct.h"
26
 
27
#define SKIP_TYPE_NONE 0
28
#define SKIP_TYPE_MPEG 1
29
#define SKIP_TYPE_ROW  2
30
#define SKIP_TYPE_COL  3
31

    
32

    
33
typedef struct Wmv2Context{
34
    MpegEncContext s;
35
    int j_type_bit;
36
    int j_type;
37
    int flag3;
38
    int flag63;
39
    int abt_flag;
40
    int abt_type;
41
    int abt_type_table[6];
42
    int per_mb_abt;
43
    int per_block_abt;
44
    int mspel_bit;
45
    int cbp_table_index;
46
    int top_left_mv_flag;
47
    int per_mb_rl_bit;
48
    int skip_type;
49
    int hshift;
50
    
51
    ScanTable abt_scantable[2];
52
    DCTELEM abt_block2[6][64] __align8;
53
}Wmv2Context;
54

    
55
static void wmv2_common_init(Wmv2Context * w){
56
    MpegEncContext * const s= &w->s;
57
        
58
    ff_init_scantable(s, &w->abt_scantable[0], wmv2_scantableA);
59
    ff_init_scantable(s, &w->abt_scantable[1], wmv2_scantableB);
60
}
61

    
62
static int encode_ext_header(Wmv2Context *w){
63
    MpegEncContext * const s= &w->s;
64
    PutBitContext pb;
65
    int code;
66
        
67
    init_put_bits(&pb, s->avctx->extradata, s->avctx->extradata_size, NULL, NULL);
68

    
69
    put_bits(&pb, 5, s->frame_rate / FRAME_RATE_BASE); //yes 29.97 -> 29
70
    put_bits(&pb, 11, FFMIN(s->bit_rate/1024, 2047));
71
    
72
    put_bits(&pb, 1, w->mspel_bit=1);
73
    put_bits(&pb, 1, w->flag3=1);
74
    put_bits(&pb, 1, w->abt_flag=1);
75
    put_bits(&pb, 1, w->j_type_bit=1);
76
    put_bits(&pb, 1, w->top_left_mv_flag=0);
77
    put_bits(&pb, 1, w->per_mb_rl_bit=1);
78
    put_bits(&pb, 3, code=1);
79
    
80
    flush_put_bits(&pb);
81

    
82
    s->slice_height = s->mb_height / code;
83
    
84
    return 0;
85
}
86

    
87
#ifdef CONFIG_ENCODERS
88
static int wmv2_encode_init(AVCodecContext *avctx){
89
    Wmv2Context * const w= avctx->priv_data;
90
    
91
    if(MPV_encode_init(avctx) < 0)
92
        return -1;
93
    
94
    wmv2_common_init(w);
95

    
96
    avctx->extradata_size= 4;
97
    avctx->extradata= av_mallocz(avctx->extradata_size + 10);
98
    encode_ext_header(w);
99
    
100
    return 0;
101
}
102

    
103
static int wmv2_encode_end(AVCodecContext *avctx){
104
    Wmv2Context * const w= avctx->priv_data;
105
    
106
    if(MPV_encode_end(avctx) < 0)
107
        return -1;
108
    
109
    avctx->extradata_size= 0;
110
    av_freep(&avctx->extradata);
111
    
112
    return 0;
113
}
114

    
115
int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number)
116
{
117
    Wmv2Context * const w= (Wmv2Context*)s;
118

    
119
    put_bits(&s->pb, 1, s->pict_type - 1);
120
    if(s->pict_type == I_TYPE){
121
        put_bits(&s->pb, 7, 0);
122
    }
123
    put_bits(&s->pb, 5, s->qscale);
124

    
125
    s->dc_table_index = 1;
126
    s->mv_table_index = 1; /* only if P frame */
127
//    s->use_skip_mb_code = 1; /* only if P frame */
128
    s->per_mb_rl_table = 0;
129
    s->mspel= 0;
130
    w->per_mb_abt=0;
131
    w->abt_type=0;
132
    w->j_type=0;
133

    
134
    if (s->pict_type == I_TYPE) {
135
        if(w->j_type_bit) put_bits(&s->pb, 1, w->j_type);
136
        
137
        if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table);
138
        
139
        if(!s->per_mb_rl_table){
140
            code012(&s->pb, s->rl_chroma_table_index);
141
            code012(&s->pb, s->rl_table_index);
142
        }
143

    
144
        put_bits(&s->pb, 1, s->dc_table_index);
145

    
146
        s->inter_intra_pred= 0;
147
        s->no_rounding = 1;
148
    }else{
149
        int cbp_index;
150

    
151
        put_bits(&s->pb, 2, SKIP_TYPE_NONE);
152
        
153
        code012(&s->pb, cbp_index=0);
154
        if(s->qscale <= 10){
155
            int map[3]= {0,2,1};
156
            w->cbp_table_index= map[cbp_index];
157
        }else if(s->qscale <= 20){
158
            int map[3]= {1,0,2};
159
            w->cbp_table_index= map[cbp_index];
160
        }else{
161
            int map[3]= {2,1,0};
162
            w->cbp_table_index= map[cbp_index];
163
        }
164

    
165
        if(w->mspel_bit) put_bits(&s->pb, 1, s->mspel);
166
    
167
        if(w->abt_flag){
168
            put_bits(&s->pb, 1, w->per_mb_abt^1);
169
            if(!w->per_mb_abt){
170
                code012(&s->pb, w->abt_type);
171
            }
172
        }
173

    
174
        if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table);
175
        
176
        if(!s->per_mb_rl_table){
177
            code012(&s->pb, s->rl_table_index);
178
            s->rl_chroma_table_index = s->rl_table_index;
179
        }
180
        put_bits(&s->pb, 1, s->dc_table_index);
181
        put_bits(&s->pb, 1, s->mv_table_index);
182
    
183
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
184
        s->no_rounding ^= 1;
185
    }
186
    s->esc3_level_length= 0;
187
    s->esc3_run_length= 0;
188

    
189
    return 0;
190
}
191

    
192
// nearly idential to wmv1 but thats just because we dont use the useless M$ crap features
193
// its duplicated here in case someone wants to add support for these carp features
194
void ff_wmv2_encode_mb(MpegEncContext * s, 
195
                       DCTELEM block[6][64],
196
                       int motion_x, int motion_y)
197
{
198
    Wmv2Context * const w= (Wmv2Context*)s;
199
    int cbp, coded_cbp, i;
200
    int pred_x, pred_y;
201
    uint8_t *coded_block;
202

    
203
    handle_slices(s);
204
    
205
    if (!s->mb_intra) {
206
        /* compute cbp */
207
        set_stat(ST_INTER_MB);
208
        cbp = 0;
209
        for (i = 0; i < 6; i++) {
210
            if (s->block_last_index[i] >= 0)
211
                cbp |= 1 << (5 - i);
212
        }
213
        
214
        put_bits(&s->pb, 
215
                 wmv2_inter_table[w->cbp_table_index][cbp + 64][1], 
216
                 wmv2_inter_table[w->cbp_table_index][cbp + 64][0]);
217

    
218
        /* motion vector */
219
        h263_pred_motion(s, 0, &pred_x, &pred_y);
220
        msmpeg4_encode_motion(s, motion_x - pred_x, 
221
                              motion_y - pred_y);
222
    } else {
223
        /* compute cbp */
224
        cbp = 0;
225
        coded_cbp = 0;
226
        for (i = 0; i < 6; i++) {
227
            int val, pred;
228
            val = (s->block_last_index[i] >= 1);
229
            cbp |= val << (5 - i);
230
            if (i < 4) {
231
                /* predict value for close blocks only for luma */
232
                pred = coded_block_pred(s, i, &coded_block);
233
                *coded_block = val;
234
                val = val ^ pred;
235
            }
236
            coded_cbp |= val << (5 - i);
237
        }
238
#if 0
239
        if (coded_cbp)
240
            printf("cbp=%x %x\n", cbp, coded_cbp);
241
#endif
242

    
243
        if (s->pict_type == I_TYPE) {
244
            set_stat(ST_INTRA_MB);
245
            put_bits(&s->pb, 
246
                     table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
247
        } else {
248
            put_bits(&s->pb, 
249
                     wmv2_inter_table[w->cbp_table_index][cbp][1], 
250
                     wmv2_inter_table[w->cbp_table_index][cbp][0]);
251
        }
252
        set_stat(ST_INTRA_MB);
253
        put_bits(&s->pb, 1, 0);        /* no AC prediction yet */
254
        if(s->inter_intra_pred){
255
            s->h263_aic_dir=0;
256
            put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
257
        }
258
    }
259

    
260
    for (i = 0; i < 6; i++) {
261
        msmpeg4_encode_block(s, block[i], i);
262
    }
263
}
264
#endif //CONFIG_ENCODERS
265

    
266
static void parse_mb_skip(Wmv2Context * w){
267
    int mb_x, mb_y;
268
    MpegEncContext * const s= &w->s;
269

    
270
    w->skip_type= get_bits(&s->gb, 2);
271
    switch(w->skip_type){
272
    case SKIP_TYPE_NONE:
273
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
274
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
275
                s->mb_type[mb_y*s->mb_width + mb_x]= 0;
276
            }
277
        }
278
        break;
279
    case SKIP_TYPE_MPEG:
280
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
281
            for(mb_x=0; mb_x<s->mb_width; mb_x++){
282
                s->mb_type[mb_y*s->mb_width + mb_x]= get_bits1(&s->gb) ? MB_TYPE_SKIPED : 0;
283
            }
284
        }
285
        break;
286
    case SKIP_TYPE_ROW:
287
        for(mb_y=0; mb_y<s->mb_height; mb_y++){
288
            if(get_bits1(&s->gb)){
289
                for(mb_x=0; mb_x<s->mb_width; mb_x++){
290
                    s->mb_type[mb_y*s->mb_width + mb_x]=  MB_TYPE_SKIPED;
291
                }
292
            }else{
293
                for(mb_x=0; mb_x<s->mb_width; mb_x++){
294
                    s->mb_type[mb_y*s->mb_width + mb_x]= get_bits1(&s->gb) ? MB_TYPE_SKIPED : 0;
295
                }
296
            }
297
        }
298
        break;
299
    case SKIP_TYPE_COL:
300
        for(mb_x=0; mb_x<s->mb_width; mb_x++){
301
            if(get_bits1(&s->gb)){
302
                for(mb_y=0; mb_y<s->mb_height; mb_y++){
303
                    s->mb_type[mb_y*s->mb_width + mb_x]=  MB_TYPE_SKIPED;
304
                }
305
            }else{
306
                for(mb_y=0; mb_y<s->mb_height; mb_y++){
307
                    s->mb_type[mb_y*s->mb_width + mb_x]= get_bits1(&s->gb) ? MB_TYPE_SKIPED : 0;
308
                }
309
            }
310
        }
311
        break;
312
    }
313
}
314

    
315
static int decode_ext_header(Wmv2Context *w){
316
    MpegEncContext * const s= &w->s;
317
    GetBitContext gb;
318
    int fps;
319
    int code;
320

    
321
    if(s->avctx->extradata_size<4) return -1;
322
    
323
    init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
324

    
325
    fps                = get_bits(&gb, 5);
326
    s->bit_rate        = get_bits(&gb, 11)*1024;
327
    w->mspel_bit       = get_bits1(&gb);
328
    w->flag3           = get_bits1(&gb);
329
    w->abt_flag        = get_bits1(&gb);
330
    w->j_type_bit      = get_bits1(&gb);
331
    w->top_left_mv_flag= get_bits1(&gb);
332
    w->per_mb_rl_bit   = get_bits1(&gb);
333
    code               = get_bits(&gb, 3);
334
    
335
    if(code==0) return -1;
336

    
337
    s->slice_height = s->mb_height / code;
338

    
339
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
340
        printf("fps:%d, br:%d, qpbit:%d, abt_flag:%d, j_type_bit:%d, tl_mv_flag:%d, mbrl_bit:%d, code:%d, flag3:%d, slices:%d\n", 
341
        fps, s->bit_rate, w->mspel_bit, w->abt_flag, w->j_type_bit, w->top_left_mv_flag, w->per_mb_rl_bit, code, w->flag3, 
342
        code);
343
    }
344
    return 0;
345
}
346

    
347
int ff_wmv2_decode_picture_header(MpegEncContext * s)
348
{
349
    Wmv2Context * const w= (Wmv2Context*)s;
350
    int code, i;
351

    
352
#if 0
353
{
354
int i;
355
for(i=0; i<s->gb.size*8; i++)
356
    printf("%d", get_bits1(&s->gb));
357
//    get_bits1(&s->gb);
358
printf("END\n");
359
return -1;
360
}
361
#endif
362
    if(s->picture_number==0)
363
        decode_ext_header(w);
364

    
365
    s->pict_type = get_bits(&s->gb, 1) + 1;
366
    if(s->pict_type == I_TYPE){
367
        code = get_bits(&s->gb, 7);
368
        printf("I7:%X/\n", code);
369
    }
370
    s->qscale = get_bits(&s->gb, 5);
371

    
372
    if (s->pict_type == I_TYPE) {
373
        if(w->j_type_bit) w->j_type= get_bits1(&s->gb);
374
        else              w->j_type= 0; //FIXME check
375
        
376
        if(!w->j_type){
377
            if(w->per_mb_rl_bit) s->per_mb_rl_table= get_bits1(&s->gb);
378
            else                 s->per_mb_rl_table= 0;
379
        
380
            if(!s->per_mb_rl_table){
381
                s->rl_chroma_table_index = decode012(&s->gb);
382
                s->rl_table_index = decode012(&s->gb);
383
            }
384

    
385
            s->dc_table_index = get_bits1(&s->gb);
386
        }
387
        s->inter_intra_pred= 0;
388
        s->no_rounding = 1;
389
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
390
            printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n", 
391
                s->qscale,
392
                s->rl_chroma_table_index,
393
                s->rl_table_index, 
394
                s->dc_table_index,
395
                s->per_mb_rl_table,
396
                w->j_type);
397
        }
398
    }else{
399
        int cbp_index;
400
        w->j_type=0;
401

    
402
        parse_mb_skip(w);
403
        cbp_index= decode012(&s->gb);
404
        if(s->qscale <= 10){
405
            int map[3]= {0,2,1};
406
            w->cbp_table_index= map[cbp_index];
407
        }else if(s->qscale <= 20){
408
            int map[3]= {1,0,2};
409
            w->cbp_table_index= map[cbp_index];
410
        }else{
411
            int map[3]= {2,1,0};
412
            w->cbp_table_index= map[cbp_index];
413
        }
414

    
415
        if(w->mspel_bit) s->mspel= get_bits1(&s->gb);
416
        else             s->mspel= 0; //FIXME check
417
    
418
        if(w->abt_flag){
419
            w->per_mb_abt= get_bits1(&s->gb)^1;
420
            if(!w->per_mb_abt){
421
                w->abt_type= decode012(&s->gb);
422
            }
423
        }
424

    
425
        if(w->per_mb_rl_bit) s->per_mb_rl_table= get_bits1(&s->gb);
426
        else                 s->per_mb_rl_table= 0;
427
        
428
        if(!s->per_mb_rl_table){
429
            s->rl_table_index = decode012(&s->gb);
430
            s->rl_chroma_table_index = s->rl_table_index;
431
        }
432

    
433
        s->dc_table_index = get_bits1(&s->gb);
434
        s->mv_table_index = get_bits1(&s->gb);
435
    
436
        s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
437
        s->no_rounding ^= 1;
438
        
439
        if(s->avctx->debug&FF_DEBUG_PICT_INFO){
440
            printf("rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d mspel:%d per_mb_abt:%d abt_type:%d cbp:%d ii:%d\n", 
441
                s->rl_table_index, 
442
                s->rl_chroma_table_index, 
443
                s->dc_table_index,
444
                s->mv_table_index,
445
                s->per_mb_rl_table,
446
                s->qscale,
447
                s->mspel,
448
                w->per_mb_abt,
449
                w->abt_type,
450
                w->cbp_table_index,
451
                s->inter_intra_pred);
452
        }
453
    }
454
    s->esc3_level_length= 0;
455
    s->esc3_run_length= 0;
456
    
457
    if(s->avctx->debug&FF_DEBUG_SKIP){
458
        for(i=0; i<s->mb_num; i++){
459
            if(i%s->mb_width==0) printf("\n");
460
            printf("%d", s->mb_type[i]);
461
        }
462
    }
463
s->picture_number++; //FIXME ?
464

    
465

    
466
//    if(w->j_type)
467
//        return wmv2_decode_j_picture(w); //FIXME
468

    
469
    if(w->j_type){
470
        printf("J-type picture isnt supported\n");
471
        return -1;
472
    }
473

    
474
    return 0;
475
}
476

    
477
static void ff_wmv2_decode_init(MpegEncContext *s){
478
}
479

    
480
static inline int wmv2_decode_motion(Wmv2Context *w, int *mx_ptr, int *my_ptr){
481
    MpegEncContext * const s= &w->s;
482
    int ret;
483
   
484
    ret= msmpeg4_decode_motion(s, mx_ptr, my_ptr);
485
   
486
    if(ret<0) return -1;
487
   
488
    if((((*mx_ptr)|(*my_ptr)) & 1) && s->mspel)
489
        w->hshift= get_bits1(&s->gb);
490
    else 
491
        w->hshift= 0;
492

    
493
//printf("%d %d  ", *mx_ptr, *my_ptr);
494
   
495
    return 0;
496
}
497

    
498
static int16_t *wmv2_pred_motion(Wmv2Context *w, int *px, int *py){
499
    MpegEncContext * const s= &w->s;
500
    int xy, wrap, diff, type;
501
    int16_t *A, *B, *C, *mot_val;
502

    
503
    wrap = s->block_wrap[0];
504
    xy = s->block_index[0];
505

    
506
    mot_val = s->motion_val[xy];
507

    
508
    A = s->motion_val[xy - 1];
509
    B = s->motion_val[xy - wrap];
510
    C = s->motion_val[xy + 2 - wrap];
511
    
512
    diff= FFMAX(ABS(A[0] - B[0]), ABS(A[1] - B[1]));
513
    
514
    if(s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag && diff >= 8)
515
        type= get_bits1(&s->gb);
516
    else
517
        type= 2;
518
    
519
    if(type == 0){
520
        *px= A[0];
521
        *py= A[1];
522
    }else if(type == 1){
523
        *px= B[0];
524
        *py= B[1];
525
    }else{
526
        /* special case for first (slice) line */
527
        if (s->first_slice_line) {
528
            *px = A[0];
529
            *py = A[1];
530
        } else {
531
            *px = mid_pred(A[0], B[0], C[0]);
532
            *py = mid_pred(A[1], B[1], C[1]);
533
        }
534
    }
535

    
536
    return mot_val;
537
}
538

    
539
static inline int wmv2_decode_inter_block(Wmv2Context *w, DCTELEM *block, int n, int cbp){
540
    MpegEncContext * const s= &w->s;
541
    static const int sub_cbp_table[3]= {2,3,1};
542
    int sub_cbp;
543

    
544
    if(!cbp){ 
545
        s->block_last_index[n] = -1;
546

    
547
        return 0;
548
    }
549
    
550
    if(w->per_block_abt)
551
        w->abt_type= decode012(&s->gb);
552
#if 0
553
    if(w->per_block_abt)
554
        printf("B%d", w->abt_type);
555
#endif
556
    w->abt_type_table[n]= w->abt_type;
557

    
558
    if(w->abt_type){
559
//        const uint8_t *scantable= w->abt_scantable[w->abt_type-1].permutated;
560
        const uint8_t *scantable= w->abt_scantable[w->abt_type-1].scantable;
561
//        const uint8_t *scantable= w->abt_type-1 ? w->abt_scantable[1].permutated : w->abt_scantable[0].scantable;
562

    
563
        sub_cbp= sub_cbp_table[ decode012(&s->gb) ];
564
//        printf("S%d", sub_cbp);
565

    
566
        if(sub_cbp&1){
567
            if (msmpeg4_decode_block(s, block, n, 1, scantable) < 0)
568
                return -1;
569
        }
570
        
571
        if(sub_cbp&2){
572
            if (msmpeg4_decode_block(s, w->abt_block2[n], n, 1, scantable) < 0)
573
                return -1;
574
        }
575
        s->block_last_index[n] = 63;
576

    
577
        return 0;
578
    }else{
579
        return msmpeg4_decode_block(s, block, n, 1, s->inter_scantable.permutated);
580
    }
581
}
582

    
583
static void wmv2_add_block(Wmv2Context *w, DCTELEM *block1, uint8_t *dst, int stride, int n){
584
    MpegEncContext * const s= &w->s;
585
    uint8_t temp[2][64];
586

    
587
    switch(w->abt_type_table[n]){
588
    case 0:
589
        if (s->block_last_index[n] >= 0) {
590
            s->dsp.idct_add (dst, stride, block1);
591
        }
592
        break;
593
    case 1:
594
        simple_idct84_add(dst           , stride, block1);
595
        simple_idct84_add(dst + 4*stride, stride, w->abt_block2[n]);
596
        memset(w->abt_block2[n], 0, 64*sizeof(DCTELEM));
597
        break;
598
    case 2:
599
        simple_idct48_add(dst           , stride, block1);
600
        simple_idct48_add(dst + 4       , stride, w->abt_block2[n]);
601
        memset(w->abt_block2[n], 0, 64*sizeof(DCTELEM));
602
        break;
603
    default:
604
        fprintf(stderr, "internal error in WMV2 abt\n");
605
    }
606
}
607

    
608
void ff_wmv2_add_mb(MpegEncContext *s, DCTELEM block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr){
609
    Wmv2Context * const w= (Wmv2Context*)s;
610

    
611
    wmv2_add_block(w, block1[0], dest_y                    , s->linesize, 0);
612
    wmv2_add_block(w, block1[1], dest_y + 8                , s->linesize, 1);
613
    wmv2_add_block(w, block1[2], dest_y +     8*s->linesize, s->linesize, 2);
614
    wmv2_add_block(w, block1[3], dest_y + 8 + 8*s->linesize, s->linesize, 3);
615
    
616
    if(s->flags&CODEC_FLAG_GRAY) return;
617
    
618
    wmv2_add_block(w, block1[4], dest_cb                   , s->uvlinesize, 4);
619
    wmv2_add_block(w, block1[5], dest_cr                   , s->uvlinesize, 5);
620
}
621

    
622
void ff_mspel_motion(MpegEncContext *s,
623
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
624
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
625
                               int motion_x, int motion_y, int h)
626
{
627
    Wmv2Context * const w= (Wmv2Context*)s;
628
    uint8_t *ptr;
629
    int dxy, offset, mx, my, src_x, src_y, v_edge_pos, linesize, uvlinesize;
630
    int emu=0;
631
    
632
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
633
    dxy = 2*dxy + w->hshift;
634
    src_x = s->mb_x * 16 + (motion_x >> 1);
635
    src_y = s->mb_y * 16 + (motion_y >> 1);
636
                
637
    /* WARNING: do no forget half pels */
638
    v_edge_pos = s->v_edge_pos;
639
    src_x = clip(src_x, -16, s->width);
640
    src_y = clip(src_y, -16, s->height);
641
    linesize   = s->linesize;
642
    uvlinesize = s->uvlinesize;
643
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
644

    
645
    if(s->flags&CODEC_FLAG_EMU_EDGE){
646
        if(src_x<1 || src_y<1 || src_x + 17  >= s->h_edge_pos
647
                              || src_y + h+1 >= v_edge_pos){
648
            ff_emulated_edge_mc(s, ptr - 1 - s->linesize, s->linesize, 19, 19, 
649
                             src_x-1, src_y-1, s->h_edge_pos, s->v_edge_pos);
650
            ptr= s->edge_emu_buffer + 1 + s->linesize;
651
            emu=1;
652
        }
653
    }
654

    
655
    s->dsp.put_mspel_pixels_tab[dxy](dest_y             , ptr             , linesize);
656
    s->dsp.put_mspel_pixels_tab[dxy](dest_y+8           , ptr+8           , linesize);
657
    s->dsp.put_mspel_pixels_tab[dxy](dest_y  +8*linesize, ptr  +8*linesize, linesize);
658
    s->dsp.put_mspel_pixels_tab[dxy](dest_y+8+8*linesize, ptr+8+8*linesize, linesize);
659

    
660
    if(s->flags&CODEC_FLAG_GRAY) return;
661

    
662
    if (s->out_format == FMT_H263) {
663
        dxy = 0;
664
        if ((motion_x & 3) != 0)
665
            dxy |= 1;
666
        if ((motion_y & 3) != 0)
667
            dxy |= 2;
668
        mx = motion_x >> 2;
669
        my = motion_y >> 2;
670
    } else {
671
        mx = motion_x / 2;
672
        my = motion_y / 2;
673
        dxy = ((my & 1) << 1) | (mx & 1);
674
        mx >>= 1;
675
        my >>= 1;
676
    }
677
    
678
    src_x = s->mb_x * 8 + mx;
679
    src_y = s->mb_y * 8 + my;
680
    src_x = clip(src_x, -8, s->width >> 1);
681
    if (src_x == (s->width >> 1))
682
        dxy &= ~1;
683
    src_y = clip(src_y, -8, s->height >> 1);
684
    if (src_y == (s->height >> 1))
685
        dxy &= ~2;
686
    offset = (src_y * uvlinesize) + src_x;
687
    ptr = ref_picture[1] + offset;
688
    if(emu){
689
        ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, 
690
                         src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
691
        ptr= s->edge_emu_buffer;
692
    }
693
    pix_op[1][dxy](dest_cb, ptr, uvlinesize, h >> 1);
694

    
695
    ptr = ref_picture[2] + offset;
696
    if(emu){
697
        ff_emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, 
698
                         src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
699
        ptr= s->edge_emu_buffer;
700
    }
701
    pix_op[1][dxy](dest_cr, ptr, uvlinesize, h >> 1);
702
}
703

    
704

    
705
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
706
{
707
    Wmv2Context * const w= (Wmv2Context*)s;
708
    int cbp, code, i;
709
    uint8_t *coded_val;
710

    
711
    if(w->j_type) return 0;
712
    
713
    s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
714
    
715
    if (s->pict_type == P_TYPE) {
716
        if(s->mb_type[s->mb_y * s->mb_width + s->mb_x]&MB_TYPE_SKIPED){
717
            /* skip mb */
718
            s->mb_intra = 0;
719
            for(i=0;i<6;i++)
720
                s->block_last_index[i] = -1;
721
            s->mv_dir = MV_DIR_FORWARD;
722
            s->mv_type = MV_TYPE_16X16;
723
            s->mv[0][0][0] = 0;
724
            s->mv[0][0][1] = 0;
725
            s->mb_skiped = 1;
726
            return 0;
727
        }
728

    
729
        code = get_vlc2(&s->gb, mb_non_intra_vlc[w->cbp_table_index].table, MB_NON_INTRA_VLC_BITS, 3);
730
        if (code < 0)
731
            return -1;
732
        s->mb_intra = (~code & 0x40) >> 6;
733
            
734
        cbp = code & 0x3f;
735
    } else {
736
        s->mb_intra = 1;
737
        code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
738
        if (code < 0){
739
            fprintf(stderr, "II-cbp illegal at %d %d\n", s->mb_x, s->mb_y);
740
            return -1;
741
        }
742
        /* predict coded block pattern */
743
        cbp = 0;
744
        for(i=0;i<6;i++) {
745
            int val = ((code >> (5 - i)) & 1);
746
            if (i < 4) {
747
                int pred = coded_block_pred(s, i, &coded_val);
748
                val = val ^ pred;
749
                *coded_val = val;
750
            }
751
            cbp |= val << (5 - i);
752
        }
753
    }
754

    
755
    if (!s->mb_intra) {
756
        int mx, my;
757
//printf("P at %d %d\n", s->mb_x, s->mb_y);
758
        wmv2_pred_motion(w, &mx, &my);
759
        
760
        if(cbp){
761
            if(s->per_mb_rl_table){
762
                s->rl_table_index = decode012(&s->gb);
763
                s->rl_chroma_table_index = s->rl_table_index;
764
            }
765

    
766
            if(w->abt_flag && w->per_mb_abt){
767
                w->per_block_abt= get_bits1(&s->gb);
768
                if(!w->per_block_abt)
769
                    w->abt_type= decode012(&s->gb);
770
            }else
771
                w->per_block_abt=0;
772
        }
773
        
774
        if (wmv2_decode_motion(w, &mx, &my) < 0)
775
            return -1;
776

    
777
        s->mv_dir = MV_DIR_FORWARD;
778
        s->mv_type = MV_TYPE_16X16;
779
        s->mv[0][0][0] = mx;
780
        s->mv[0][0][1] = my;
781

    
782
        for (i = 0; i < 6; i++) {
783
            if (wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1) < 0)
784
            {
785
                fprintf(stderr,"\nerror while decoding inter block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
786
                return -1;
787
            }
788
        }    
789
    } else {
790
//if(s->pict_type==P_TYPE)
791
//   printf("%d%d ", s->inter_intra_pred, cbp);
792
//printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24));
793
        s->ac_pred = get_bits1(&s->gb);
794
        if(s->inter_intra_pred){
795
            s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
796
//            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
797
        }
798
        if(s->per_mb_rl_table && cbp){
799
            s->rl_table_index = decode012(&s->gb);
800
            s->rl_chroma_table_index = s->rl_table_index;
801
        }
802
    
803
        for (i = 0; i < 6; i++) {
804
            if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
805
            {
806
                fprintf(stderr,"\nerror while decoding intra block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
807
                return -1;
808
            }
809
        }    
810
    }
811

    
812
    return 0;
813
}
814

    
815
static int wmv2_decode_init(AVCodecContext *avctx){
816
    Wmv2Context * const w= avctx->priv_data;
817
    
818
    if(ff_h263_decode_init(avctx) < 0)
819
        return -1;
820
    
821
    wmv2_common_init(w);
822
    
823
    return 0;
824
}
825

    
826
AVCodec wmv2_decoder = {
827
    "wmv2",
828
    CODEC_TYPE_VIDEO,
829
    CODEC_ID_WMV2,
830
    sizeof(Wmv2Context),
831
    wmv2_decode_init,
832
    NULL,
833
    ff_h263_decode_end,
834
    ff_h263_decode_frame,
835
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
836
};
837

    
838
#ifdef CONFIG_ENCODERS
839
AVCodec wmv2_encoder = {
840
    "wmv2",
841
    CODEC_TYPE_VIDEO,
842
    CODEC_ID_WMV2,
843
    sizeof(Wmv2Context),
844
    wmv2_encode_init,
845
    MPV_encode_picture,
846
    MPV_encode_end,
847
};
848
#endif