split wmv2 in its own file
[ffmpeg.git] / libavcodec / wmv2.c
1 /*
2  * Copyright (c) 2002 The FFmpeg Project.
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 /**
22  * @file wmv2.c
23  * wmv2 codec.
24  */
25
26 #include "avcodec.h"
27 #include "dsputil.h"
28 #include "mpegvideo.h"
29 #include "msmpeg4.h"
30 #include "msmpeg4data.h"
31 #include "simple_idct.h"
32
33 #define SKIP_TYPE_NONE 0
34 #define SKIP_TYPE_MPEG 1
35 #define SKIP_TYPE_ROW  2
36 #define SKIP_TYPE_COL  3
37
38
39 typedef struct Wmv2Context{
40     MpegEncContext s;
41     int j_type_bit;
42     int j_type;
43     int abt_flag;
44     int abt_type;
45     int abt_type_table[6];
46     int per_mb_abt;
47     int per_block_abt;
48     int mspel_bit;
49     int cbp_table_index;
50     int top_left_mv_flag;
51     int per_mb_rl_bit;
52     int skip_type;
53     int hshift;
54
55     ScanTable abt_scantable[2];
56     DECLARE_ALIGNED_8(DCTELEM, abt_block2[6][64]);
57 }Wmv2Context;
58
59 static void wmv2_common_init(Wmv2Context * w){
60     MpegEncContext * const s= &w->s;
61
62     ff_init_scantable(s->dsp.idct_permutation, &w->abt_scantable[0], wmv2_scantableA);
63     ff_init_scantable(s->dsp.idct_permutation, &w->abt_scantable[1], wmv2_scantableB);
64 }
65
66 #ifdef CONFIG_WMV2_ENCODER
67
68 static int encode_ext_header(Wmv2Context *w){
69     MpegEncContext * const s= &w->s;
70     PutBitContext pb;
71     int code;
72
73     init_put_bits(&pb, s->avctx->extradata, s->avctx->extradata_size);
74
75     put_bits(&pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
76     put_bits(&pb, 11, FFMIN(s->bit_rate/1024, 2047));
77
78     put_bits(&pb, 1, w->mspel_bit=1);
79     put_bits(&pb, 1, s->loop_filter);
80     put_bits(&pb, 1, w->abt_flag=1);
81     put_bits(&pb, 1, w->j_type_bit=1);
82     put_bits(&pb, 1, w->top_left_mv_flag=0);
83     put_bits(&pb, 1, w->per_mb_rl_bit=1);
84     put_bits(&pb, 3, code=1);
85
86     flush_put_bits(&pb);
87
88     s->slice_height = s->mb_height / code;
89
90     return 0;
91 }
92
93 static int wmv2_encode_init(AVCodecContext *avctx){
94     Wmv2Context * const w= avctx->priv_data;
95
96     if(MPV_encode_init(avctx) < 0)
97         return -1;
98
99     wmv2_common_init(w);
100
101     avctx->extradata_size= 4;
102     avctx->extradata= av_mallocz(avctx->extradata_size + 10);
103     encode_ext_header(w);
104
105     return 0;
106 }
107
108 #if 0 /* unused, remove? */
109 static int wmv2_encode_end(AVCodecContext *avctx){
110
111     if(MPV_encode_end(avctx) < 0)
112         return -1;
113
114     avctx->extradata_size= 0;
115     av_freep(&avctx->extradata);
116
117     return 0;
118 }
119 #endif
120
121 int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number)
122 {
123     Wmv2Context * const w= (Wmv2Context*)s;
124
125     put_bits(&s->pb, 1, s->pict_type - 1);
126     if(s->pict_type == I_TYPE){
127         put_bits(&s->pb, 7, 0);
128     }
129     put_bits(&s->pb, 5, s->qscale);
130
131     s->dc_table_index = 1;
132     s->mv_table_index = 1; /* only if P frame */
133 //    s->use_skip_mb_code = 1; /* only if P frame */
134     s->per_mb_rl_table = 0;
135     s->mspel= 0;
136     w->per_mb_abt=0;
137     w->abt_type=0;
138     w->j_type=0;
139
140     assert(s->flipflop_rounding);
141
142     if (s->pict_type == I_TYPE) {
143         assert(s->no_rounding==1);
144         if(w->j_type_bit) put_bits(&s->pb, 1, w->j_type);
145
146         if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table);
147
148         if(!s->per_mb_rl_table){
149             ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
150             ff_msmpeg4_code012(&s->pb, s->rl_table_index);
151         }
152
153         put_bits(&s->pb, 1, s->dc_table_index);
154
155         s->inter_intra_pred= 0;
156     }else{
157         int cbp_index;
158
159         put_bits(&s->pb, 2, SKIP_TYPE_NONE);
160
161         ff_msmpeg4_code012(&s->pb, cbp_index=0);
162         if(s->qscale <= 10){
163             int map[3]= {0,2,1};
164             w->cbp_table_index= map[cbp_index];
165         }else if(s->qscale <= 20){
166             int map[3]= {1,0,2};
167             w->cbp_table_index= map[cbp_index];
168         }else{
169             int map[3]= {2,1,0};
170             w->cbp_table_index= map[cbp_index];
171         }
172
173         if(w->mspel_bit) put_bits(&s->pb, 1, s->mspel);
174
175         if(w->abt_flag){
176             put_bits(&s->pb, 1, w->per_mb_abt^1);
177             if(!w->per_mb_abt){
178                 ff_msmpeg4_code012(&s->pb, w->abt_type);
179             }
180         }
181
182         if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table);
183
184         if(!s->per_mb_rl_table){
185             ff_msmpeg4_code012(&s->pb, s->rl_table_index);
186             s->rl_chroma_table_index = s->rl_table_index;
187         }
188         put_bits(&s->pb, 1, s->dc_table_index);
189         put_bits(&s->pb, 1, s->mv_table_index);
190
191         s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
192     }
193     s->esc3_level_length= 0;
194     s->esc3_run_length= 0;
195
196     return 0;
197 }
198
199 /* Nearly identical to wmv1 but that is just because we do not use the
200  * useless M$ crap features. It is duplicated here in case someone wants
201  * to add support for these crap features. */
202 void ff_wmv2_encode_mb(MpegEncContext * s,
203                        DCTELEM block[6][64],
204                        int motion_x, int motion_y)
205 {
206     Wmv2Context * const w= (Wmv2Context*)s;
207     int cbp, coded_cbp, i;
208     int pred_x, pred_y;
209     uint8_t *coded_block;
210
211     ff_msmpeg4_handle_slices(s);
212
213     if (!s->mb_intra) {
214         /* compute cbp */
215         cbp = 0;
216         for (i = 0; i < 6; i++) {
217             if (s->block_last_index[i] >= 0)
218                 cbp |= 1 << (5 - i);
219         }
220
221         put_bits(&s->pb,
222                  wmv2_inter_table[w->cbp_table_index][cbp + 64][1],
223                  wmv2_inter_table[w->cbp_table_index][cbp + 64][0]);
224
225         /* motion vector */
226         h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
227         ff_msmpeg4_encode_motion(s, motion_x - pred_x,
228                               motion_y - pred_y);
229     } else {
230         /* compute cbp */
231         cbp = 0;
232         coded_cbp = 0;
233         for (i = 0; i < 6; i++) {
234             int val, pred;
235             val = (s->block_last_index[i] >= 1);
236             cbp |= val << (5 - i);
237             if (i < 4) {
238                 /* predict value for close blocks only for luma */
239                 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
240                 *coded_block = val;
241                 val = val ^ pred;
242             }
243             coded_cbp |= val << (5 - i);
244         }
245 #if 0
246         if (coded_cbp)
247             printf("cbp=%x %x\n", cbp, coded_cbp);
248 #endif
249
250         if (s->pict_type == I_TYPE) {
251             put_bits(&s->pb,
252                      ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
253         } else {
254             put_bits(&s->pb,
255                      wmv2_inter_table[w->cbp_table_index][cbp][1],
256                      wmv2_inter_table[w->cbp_table_index][cbp][0]);
257         }
258         put_bits(&s->pb, 1, 0);         /* no AC prediction yet */
259         if(s->inter_intra_pred){
260             s->h263_aic_dir=0;
261             put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
262         }
263     }
264
265     for (i = 0; i < 6; i++) {
266         ff_msmpeg4_encode_block(s, block[i], i);
267     }
268 }
269 #endif //CONFIG_WMV2_ENCODER
270
271 static void parse_mb_skip(Wmv2Context * w){
272     int mb_x, mb_y;
273     MpegEncContext * const s= &w->s;
274     uint32_t * const mb_type= s->current_picture_ptr->mb_type;
275
276     w->skip_type= get_bits(&s->gb, 2);
277     switch(w->skip_type){
278     case SKIP_TYPE_NONE:
279         for(mb_y=0; mb_y<s->mb_height; mb_y++){
280             for(mb_x=0; mb_x<s->mb_width; mb_x++){
281                 mb_type[mb_y*s->mb_stride + mb_x]= MB_TYPE_16x16 | MB_TYPE_L0;
282             }
283         }
284         break;
285     case SKIP_TYPE_MPEG:
286         for(mb_y=0; mb_y<s->mb_height; mb_y++){
287             for(mb_x=0; mb_x<s->mb_width; mb_x++){
288                 mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
289             }
290         }
291         break;
292     case SKIP_TYPE_ROW:
293         for(mb_y=0; mb_y<s->mb_height; mb_y++){
294             if(get_bits1(&s->gb)){
295                 for(mb_x=0; mb_x<s->mb_width; mb_x++){
296                     mb_type[mb_y*s->mb_stride + mb_x]=  MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
297                 }
298             }else{
299                 for(mb_x=0; mb_x<s->mb_width; mb_x++){
300                     mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
301                 }
302             }
303         }
304         break;
305     case SKIP_TYPE_COL:
306         for(mb_x=0; mb_x<s->mb_width; mb_x++){
307             if(get_bits1(&s->gb)){
308                 for(mb_y=0; mb_y<s->mb_height; mb_y++){
309                     mb_type[mb_y*s->mb_stride + mb_x]=  MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
310                 }
311             }else{
312                 for(mb_y=0; mb_y<s->mb_height; mb_y++){
313                     mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
314                 }
315             }
316         }
317         break;
318     }
319 }
320
321 static int decode_ext_header(Wmv2Context *w){
322     MpegEncContext * const s= &w->s;
323     GetBitContext gb;
324     int fps;
325     int code;
326
327     if(s->avctx->extradata_size<4) return -1;
328
329     init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
330
331     fps                = get_bits(&gb, 5);
332     s->bit_rate        = get_bits(&gb, 11)*1024;
333     w->mspel_bit       = get_bits1(&gb);
334     s->loop_filter     = get_bits1(&gb);
335     w->abt_flag        = get_bits1(&gb);
336     w->j_type_bit      = get_bits1(&gb);
337     w->top_left_mv_flag= get_bits1(&gb);
338     w->per_mb_rl_bit   = get_bits1(&gb);
339     code               = get_bits(&gb, 3);
340
341     if(code==0) return -1;
342
343     s->slice_height = s->mb_height / code;
344
345     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
346         av_log(s->avctx, AV_LOG_DEBUG, "fps:%d, br:%d, qpbit:%d, abt_flag:%d, j_type_bit:%d, tl_mv_flag:%d, mbrl_bit:%d, code:%d, loop_filter:%d, slices:%d\n",
347         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, s->loop_filter,
348         code);
349     }
350     return 0;
351 }
352
353 int ff_wmv2_decode_picture_header(MpegEncContext * s)
354 {
355     Wmv2Context * const w= (Wmv2Context*)s;
356     int code;
357
358 #if 0
359 {
360 int i;
361 for(i=0; i<s->gb.size*8; i++)
362     printf("%d", get_bits1(&s->gb));
363 //    get_bits1(&s->gb);
364 printf("END\n");
365 return -1;
366 }
367 #endif
368     if(s->picture_number==0)
369         decode_ext_header(w);
370
371     s->pict_type = get_bits1(&s->gb) + 1;
372     if(s->pict_type == I_TYPE){
373         code = get_bits(&s->gb, 7);
374         av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
375     }
376     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
377     if(s->qscale < 0)
378        return -1;
379
380     return 0;
381 }
382
383 int ff_wmv2_decode_secondary_picture_header(MpegEncContext * s)
384 {
385     Wmv2Context * const w= (Wmv2Context*)s;
386
387     if (s->pict_type == I_TYPE) {
388         if(w->j_type_bit) w->j_type= get_bits1(&s->gb);
389         else              w->j_type= 0; //FIXME check
390
391         if(!w->j_type){
392             if(w->per_mb_rl_bit) s->per_mb_rl_table= get_bits1(&s->gb);
393             else                 s->per_mb_rl_table= 0;
394
395             if(!s->per_mb_rl_table){
396                 s->rl_chroma_table_index = decode012(&s->gb);
397                 s->rl_table_index = decode012(&s->gb);
398             }
399
400             s->dc_table_index = get_bits1(&s->gb);
401         }
402         s->inter_intra_pred= 0;
403         s->no_rounding = 1;
404         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
405             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n",
406                 s->qscale,
407                 s->rl_chroma_table_index,
408                 s->rl_table_index,
409                 s->dc_table_index,
410                 s->per_mb_rl_table,
411                 w->j_type);
412         }
413     }else{
414         int cbp_index;
415         w->j_type=0;
416
417         parse_mb_skip(w);
418         cbp_index= decode012(&s->gb);
419         if(s->qscale <= 10){
420             int map[3]= {0,2,1};
421             w->cbp_table_index= map[cbp_index];
422         }else if(s->qscale <= 20){
423             int map[3]= {1,0,2};
424             w->cbp_table_index= map[cbp_index];
425         }else{
426             int map[3]= {2,1,0};
427             w->cbp_table_index= map[cbp_index];
428         }
429
430         if(w->mspel_bit) s->mspel= get_bits1(&s->gb);
431         else             s->mspel= 0; //FIXME check
432
433         if(w->abt_flag){
434             w->per_mb_abt= get_bits1(&s->gb)^1;
435             if(!w->per_mb_abt){
436                 w->abt_type= decode012(&s->gb);
437             }
438         }
439
440         if(w->per_mb_rl_bit) s->per_mb_rl_table= get_bits1(&s->gb);
441         else                 s->per_mb_rl_table= 0;
442
443         if(!s->per_mb_rl_table){
444             s->rl_table_index = decode012(&s->gb);
445             s->rl_chroma_table_index = s->rl_table_index;
446         }
447
448         s->dc_table_index = get_bits1(&s->gb);
449         s->mv_table_index = get_bits1(&s->gb);
450
451         s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
452         s->no_rounding ^= 1;
453
454         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
455             av_log(s->avctx, AV_LOG_DEBUG, "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",
456                 s->rl_table_index,
457                 s->rl_chroma_table_index,
458                 s->dc_table_index,
459                 s->mv_table_index,
460                 s->per_mb_rl_table,
461                 s->qscale,
462                 s->mspel,
463                 w->per_mb_abt,
464                 w->abt_type,
465                 w->cbp_table_index,
466                 s->inter_intra_pred);
467         }
468     }
469     s->esc3_level_length= 0;
470     s->esc3_run_length= 0;
471
472 s->picture_number++; //FIXME ?
473
474
475 //    if(w->j_type)
476 //        return wmv2_decode_j_picture(w); //FIXME
477
478     if(w->j_type){
479         av_log(s->avctx, AV_LOG_ERROR, "J-type picture is not supported\n");
480         return -1;
481     }
482
483     return 0;
484 }
485
486 static inline int wmv2_decode_motion(Wmv2Context *w, int *mx_ptr, int *my_ptr){
487     MpegEncContext * const s= &w->s;
488     int ret;
489
490     ret= ff_msmpeg4_decode_motion(s, mx_ptr, my_ptr);
491
492     if(ret<0) return -1;
493
494     if((((*mx_ptr)|(*my_ptr)) & 1) && s->mspel)
495         w->hshift= get_bits1(&s->gb);
496     else
497         w->hshift= 0;
498
499 //printf("%d %d  ", *mx_ptr, *my_ptr);
500
501     return 0;
502 }
503
504 static int16_t *wmv2_pred_motion(Wmv2Context *w, int *px, int *py){
505     MpegEncContext * const s= &w->s;
506     int xy, wrap, diff, type;
507     int16_t *A, *B, *C, *mot_val;
508
509     wrap = s->b8_stride;
510     xy = s->block_index[0];
511
512     mot_val = s->current_picture.motion_val[0][xy];
513
514     A = s->current_picture.motion_val[0][xy - 1];
515     B = s->current_picture.motion_val[0][xy - wrap];
516     C = s->current_picture.motion_val[0][xy + 2 - wrap];
517
518     if(s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag)
519         diff= FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1]));
520     else
521         diff=0;
522
523     if(diff >= 8)
524         type= get_bits1(&s->gb);
525     else
526         type= 2;
527
528     if(type == 0){
529         *px= A[0];
530         *py= A[1];
531     }else if(type == 1){
532         *px= B[0];
533         *py= B[1];
534     }else{
535         /* special case for first (slice) line */
536         if (s->first_slice_line) {
537             *px = A[0];
538             *py = A[1];
539         } else {
540             *px = mid_pred(A[0], B[0], C[0]);
541             *py = mid_pred(A[1], B[1], C[1]);
542         }
543     }
544
545     return mot_val;
546 }
547
548 static inline int wmv2_decode_inter_block(Wmv2Context *w, DCTELEM *block, int n, int cbp){
549     MpegEncContext * const s= &w->s;
550     static const int sub_cbp_table[3]= {2,3,1};
551     int sub_cbp;
552
553     if(!cbp){
554         s->block_last_index[n] = -1;
555
556         return 0;
557     }
558
559     if(w->per_block_abt)
560         w->abt_type= decode012(&s->gb);
561 #if 0
562     if(w->per_block_abt)
563         printf("B%d", w->abt_type);
564 #endif
565     w->abt_type_table[n]= w->abt_type;
566
567     if(w->abt_type){
568 //        const uint8_t *scantable= w->abt_scantable[w->abt_type-1].permutated;
569         const uint8_t *scantable= w->abt_scantable[w->abt_type-1].scantable;
570 //        const uint8_t *scantable= w->abt_type-1 ? w->abt_scantable[1].permutated : w->abt_scantable[0].scantable;
571
572         sub_cbp= sub_cbp_table[ decode012(&s->gb) ];
573 //        printf("S%d", sub_cbp);
574
575         if(sub_cbp&1){
576             if (ff_msmpeg4_decode_block(s, block, n, 1, scantable) < 0)
577                 return -1;
578         }
579
580         if(sub_cbp&2){
581             if (ff_msmpeg4_decode_block(s, w->abt_block2[n], n, 1, scantable) < 0)
582                 return -1;
583         }
584         s->block_last_index[n] = 63;
585
586         return 0;
587     }else{
588         return ff_msmpeg4_decode_block(s, block, n, 1, s->inter_scantable.permutated);
589     }
590 }
591
592 static void wmv2_add_block(Wmv2Context *w, DCTELEM *block1, uint8_t *dst, int stride, int n){
593     MpegEncContext * const s= &w->s;
594
595   if (s->block_last_index[n] >= 0) {
596     switch(w->abt_type_table[n]){
597     case 0:
598         s->dsp.idct_add (dst, stride, block1);
599         break;
600     case 1:
601         simple_idct84_add(dst           , stride, block1);
602         simple_idct84_add(dst + 4*stride, stride, w->abt_block2[n]);
603         memset(w->abt_block2[n], 0, 64*sizeof(DCTELEM));
604         break;
605     case 2:
606         simple_idct48_add(dst           , stride, block1);
607         simple_idct48_add(dst + 4       , stride, w->abt_block2[n]);
608         memset(w->abt_block2[n], 0, 64*sizeof(DCTELEM));
609         break;
610     default:
611         av_log(s->avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n");
612     }
613   }
614 }
615
616 void ff_wmv2_add_mb(MpegEncContext *s, DCTELEM block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr){
617     Wmv2Context * const w= (Wmv2Context*)s;
618
619     wmv2_add_block(w, block1[0], dest_y                    , s->linesize, 0);
620     wmv2_add_block(w, block1[1], dest_y + 8                , s->linesize, 1);
621     wmv2_add_block(w, block1[2], dest_y +     8*s->linesize, s->linesize, 2);
622     wmv2_add_block(w, block1[3], dest_y + 8 + 8*s->linesize, s->linesize, 3);
623
624     if(s->flags&CODEC_FLAG_GRAY) return;
625
626     wmv2_add_block(w, block1[4], dest_cb                   , s->uvlinesize, 4);
627     wmv2_add_block(w, block1[5], dest_cr                   , s->uvlinesize, 5);
628 }
629
630 void ff_mspel_motion(MpegEncContext *s,
631                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
632                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
633                                int motion_x, int motion_y, int h)
634 {
635     Wmv2Context * const w= (Wmv2Context*)s;
636     uint8_t *ptr;
637     int dxy, offset, mx, my, src_x, src_y, v_edge_pos, linesize, uvlinesize;
638     int emu=0;
639
640     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
641     dxy = 2*dxy + w->hshift;
642     src_x = s->mb_x * 16 + (motion_x >> 1);
643     src_y = s->mb_y * 16 + (motion_y >> 1);
644
645     /* WARNING: do no forget half pels */
646     v_edge_pos = s->v_edge_pos;
647     src_x = av_clip(src_x, -16, s->width);
648     src_y = av_clip(src_y, -16, s->height);
649
650     if(src_x<=-16 || src_x >= s->width)
651         dxy &= ~3;
652     if(src_y<=-16 || src_y >= s->height)
653         dxy &= ~4;
654
655     linesize   = s->linesize;
656     uvlinesize = s->uvlinesize;
657     ptr = ref_picture[0] + (src_y * linesize) + src_x;
658
659     if(s->flags&CODEC_FLAG_EMU_EDGE){
660         if(src_x<1 || src_y<1 || src_x + 17  >= s->h_edge_pos
661                               || src_y + h+1 >= v_edge_pos){
662             ff_emulated_edge_mc(s->edge_emu_buffer, ptr - 1 - s->linesize, s->linesize, 19, 19,
663                              src_x-1, src_y-1, s->h_edge_pos, s->v_edge_pos);
664             ptr= s->edge_emu_buffer + 1 + s->linesize;
665             emu=1;
666         }
667     }
668
669     s->dsp.put_mspel_pixels_tab[dxy](dest_y             , ptr             , linesize);
670     s->dsp.put_mspel_pixels_tab[dxy](dest_y+8           , ptr+8           , linesize);
671     s->dsp.put_mspel_pixels_tab[dxy](dest_y  +8*linesize, ptr  +8*linesize, linesize);
672     s->dsp.put_mspel_pixels_tab[dxy](dest_y+8+8*linesize, ptr+8+8*linesize, linesize);
673
674     if(s->flags&CODEC_FLAG_GRAY) return;
675
676     if (s->out_format == FMT_H263) {
677         dxy = 0;
678         if ((motion_x & 3) != 0)
679             dxy |= 1;
680         if ((motion_y & 3) != 0)
681             dxy |= 2;
682         mx = motion_x >> 2;
683         my = motion_y >> 2;
684     } else {
685         mx = motion_x / 2;
686         my = motion_y / 2;
687         dxy = ((my & 1) << 1) | (mx & 1);
688         mx >>= 1;
689         my >>= 1;
690     }
691
692     src_x = s->mb_x * 8 + mx;
693     src_y = s->mb_y * 8 + my;
694     src_x = av_clip(src_x, -8, s->width >> 1);
695     if (src_x == (s->width >> 1))
696         dxy &= ~1;
697     src_y = av_clip(src_y, -8, s->height >> 1);
698     if (src_y == (s->height >> 1))
699         dxy &= ~2;
700     offset = (src_y * uvlinesize) + src_x;
701     ptr = ref_picture[1] + offset;
702     if(emu){
703         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
704                          src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
705         ptr= s->edge_emu_buffer;
706     }
707     pix_op[1][dxy](dest_cb, ptr, uvlinesize, h >> 1);
708
709     ptr = ref_picture[2] + offset;
710     if(emu){
711         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
712                          src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
713         ptr= s->edge_emu_buffer;
714     }
715     pix_op[1][dxy](dest_cr, ptr, uvlinesize, h >> 1);
716 }
717
718
719 int ff_wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
720 {
721     Wmv2Context * const w= (Wmv2Context*)s;
722     int cbp, code, i;
723     uint8_t *coded_val;
724
725     if(w->j_type) return 0;
726
727     if (s->pict_type == P_TYPE) {
728         if(IS_SKIP(s->current_picture.mb_type[s->mb_y * s->mb_stride + s->mb_x])){
729             /* skip mb */
730             s->mb_intra = 0;
731             for(i=0;i<6;i++)
732                 s->block_last_index[i] = -1;
733             s->mv_dir = MV_DIR_FORWARD;
734             s->mv_type = MV_TYPE_16X16;
735             s->mv[0][0][0] = 0;
736             s->mv[0][0][1] = 0;
737             s->mb_skipped = 1;
738             w->hshift=0;
739             return 0;
740         }
741
742         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[w->cbp_table_index].table, MB_NON_INTRA_VLC_BITS, 3);
743         if (code < 0)
744             return -1;
745         s->mb_intra = (~code & 0x40) >> 6;
746
747         cbp = code & 0x3f;
748     } else {
749         s->mb_intra = 1;
750         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
751         if (code < 0){
752             av_log(s->avctx, AV_LOG_ERROR, "II-cbp illegal at %d %d\n", s->mb_x, s->mb_y);
753             return -1;
754         }
755         /* predict coded block pattern */
756         cbp = 0;
757         for(i=0;i<6;i++) {
758             int val = ((code >> (5 - i)) & 1);
759             if (i < 4) {
760                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
761                 val = val ^ pred;
762                 *coded_val = val;
763             }
764             cbp |= val << (5 - i);
765         }
766     }
767
768     if (!s->mb_intra) {
769         int mx, my;
770 //printf("P at %d %d\n", s->mb_x, s->mb_y);
771         wmv2_pred_motion(w, &mx, &my);
772
773         if(cbp){
774             s->dsp.clear_blocks(s->block[0]);
775             if(s->per_mb_rl_table){
776                 s->rl_table_index = decode012(&s->gb);
777                 s->rl_chroma_table_index = s->rl_table_index;
778             }
779
780             if(w->abt_flag && w->per_mb_abt){
781                 w->per_block_abt= get_bits1(&s->gb);
782                 if(!w->per_block_abt)
783                     w->abt_type= decode012(&s->gb);
784             }else
785                 w->per_block_abt=0;
786         }
787
788         if (wmv2_decode_motion(w, &mx, &my) < 0)
789             return -1;
790
791         s->mv_dir = MV_DIR_FORWARD;
792         s->mv_type = MV_TYPE_16X16;
793         s->mv[0][0][0] = mx;
794         s->mv[0][0][1] = my;
795
796         for (i = 0; i < 6; i++) {
797             if (wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1) < 0)
798             {
799                 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding inter block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
800                 return -1;
801             }
802         }
803     } else {
804 //if(s->pict_type==P_TYPE)
805 //   printf("%d%d ", s->inter_intra_pred, cbp);
806 //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));
807         s->ac_pred = get_bits1(&s->gb);
808         if(s->inter_intra_pred){
809             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
810 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
811         }
812         if(s->per_mb_rl_table && cbp){
813             s->rl_table_index = decode012(&s->gb);
814             s->rl_chroma_table_index = s->rl_table_index;
815         }
816
817         s->dsp.clear_blocks(s->block[0]);
818         for (i = 0; i < 6; i++) {
819             if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
820             {
821                 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding intra block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
822                 return -1;
823             }
824         }
825     }
826
827     return 0;
828 }
829
830 static int wmv2_decode_init(AVCodecContext *avctx){
831     Wmv2Context * const w= avctx->priv_data;
832
833     if(ff_h263_decode_init(avctx) < 0)
834         return -1;
835
836     wmv2_common_init(w);
837
838     return 0;
839 }
840
841 #ifdef CONFIG_WMV2_DECODER
842 AVCodec wmv2_decoder = {
843     "wmv2",
844     CODEC_TYPE_VIDEO,
845     CODEC_ID_WMV2,
846     sizeof(Wmv2Context),
847     wmv2_decode_init,
848     NULL,
849     ff_h263_decode_end,
850     ff_h263_decode_frame,
851     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
852 };
853 #endif
854
855 #ifdef CONFIG_WMV2_ENCODER
856 AVCodec wmv2_encoder = {
857     "wmv2",
858     CODEC_TYPE_VIDEO,
859     CODEC_ID_WMV2,
860     sizeof(Wmv2Context),
861     wmv2_encode_init,
862     MPV_encode_picture,
863     MPV_encode_end,
864     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
865 };
866 #endif