068dd51d37e795806425d61f605e7371c0a42ec7
[ffmpeg.git] / libavcodec / svq1.c
1 /*
2  * 
3  * Copyright (C) 2002 the xine project
4  * Copyright (C) 2002 the ffmpeg project
5  * 
6  * This library 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 of the License, or (at your option) any later version.
10  *
11  * This library 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 this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  * (SVQ1 Decoder)
21  * Ported to mplayer by Arpi <arpi@thot.banki.hu>
22  * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
23  *
24  * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
25  */
26
27 /**
28  * @file svq1.c
29  * Sorenson Vector Quantizer #1 (SVQ1) video codec.
30  * For more information of the SVQ1 algorithm, visit:
31  *   http://www.pcisys.net/~melanson/codecs/
32  */
33
34
35 //#define DEBUG_SVQ1
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40 #include <limits.h>
41
42 #include "common.h"
43 #include "avcodec.h"
44 #include "dsputil.h"
45 #include "mpegvideo.h"
46 #include "bswap.h"
47
48 #undef NDEBUG
49 #include <assert.h>
50
51 extern const uint8_t mvtab[33][2];
52
53 static VLC svq1_block_type;
54 static VLC svq1_motion_component;
55 static VLC svq1_intra_multistage[6];
56 static VLC svq1_inter_multistage[6];
57 static VLC svq1_intra_mean;
58 static VLC svq1_inter_mean;
59
60 #define SVQ1_BLOCK_SKIP         0
61 #define SVQ1_BLOCK_INTER        1
62 #define SVQ1_BLOCK_INTER_4V     2
63 #define SVQ1_BLOCK_INTRA        3
64
65 typedef struct SVQ1Context {
66     MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independant of MpegEncContext, so this will be removed then (FIXME/XXX)
67     AVCodecContext *avctx;
68     DSPContext dsp;
69     AVFrame picture;
70     AVFrame current_picture;
71     AVFrame last_picture;
72     PutBitContext pb;
73     GetBitContext gb;
74     
75     PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
76
77     int frame_width;
78     int frame_height;
79
80     /* Y plane block dimensions */
81     int y_block_width;
82     int y_block_height;
83
84     /* U & V plane (C planes) block dimensions */
85     int c_block_width;
86     int c_block_height;
87     
88     uint16_t *mb_type;
89     uint32_t *dummy;
90     int16_t (*motion_val8[3])[2];
91     int16_t (*motion_val16[3])[2];
92
93     int64_t rd_total;
94 } SVQ1Context;
95
96 /* motion vector (prediction) */
97 typedef struct svq1_pmv_s {
98   int            x;
99   int            y;
100 } svq1_pmv_t;
101
102 #include "svq1_cb.h"
103 #include "svq1_vlc.h"
104
105 static const uint16_t checksum_table[256] = {
106   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
107   0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
108   0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
109   0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
110   0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
111   0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
112   0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
113   0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
114   0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
115   0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
116   0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
117   0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
118   0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
119   0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
120   0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
121   0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
122   0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
123   0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
124   0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
125   0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
126   0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
127   0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
128   0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
129   0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
130   0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
131   0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
132   0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
133   0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
134   0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
135   0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
136   0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
137   0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
138 };
139
140 static const uint8_t string_table[256] = {
141   0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
142   0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
143   0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
144   0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
145   0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
146   0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
147   0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
148   0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
149   0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
150   0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
151   0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
152   0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
153   0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
154   0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
155   0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
156   0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
157   0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
158   0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
159   0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
160   0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
161   0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
162   0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
163   0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
164   0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
165   0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
166   0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
167   0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
168   0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
169   0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
170   0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
171   0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
172   0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
173 };
174
175 #define SVQ1_PROCESS_VECTOR()\
176     for (; level > 0; i++) {\
177       /* process next depth */\
178       if (i == m) {\
179         m = n;\
180         if (--level == 0)\
181           break;\
182       }\
183       /* divide block if next bit set */\
184       if (get_bits (bitbuf, 1) == 0)\
185         break;\
186       /* add child nodes */\
187       list[n++] = list[i];\
188       list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
189     }
190
191 #define SVQ1_ADD_CODEBOOK()\
192           /* add codebook entries to vector */\
193           for (j=0; j < stages; j++) {\
194             n3  = codebook[entries[j]] ^ 0x80808080;\
195             n1 += ((n3 & 0xFF00FF00) >> 8);\
196             n2 +=  (n3 & 0x00FF00FF);\
197           }\
198 \
199           /* clip to [0..255] */\
200           if (n1 & 0xFF00FF00) {\
201             n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
202             n1 += 0x7F007F00;\
203             n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
204             n1 &= (n3 & 0x00FF00FF);\
205           }\
206 \
207           if (n2 & 0xFF00FF00) {\
208             n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
209             n2 += 0x7F007F00;\
210             n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
211             n2 &= (n3 & 0x00FF00FF);\
212           }
213
214 #define SVQ1_DO_CODEBOOK_INTRA()\
215       for (y=0; y < height; y++) {\
216         for (x=0; x < (width / 4); x++, codebook++) {\
217         n1 = n4;\
218         n2 = n4;\
219         SVQ1_ADD_CODEBOOK()\
220         /* store result */\
221         dst[x] = (n1 << 8) | n2;\
222         }\
223         dst += (pitch / 4);\
224       }
225
226 #define SVQ1_DO_CODEBOOK_NONINTRA()\
227       for (y=0; y < height; y++) {\
228         for (x=0; x < (width / 4); x++, codebook++) {\
229         n3 = dst[x];\
230         /* add mean value to vector */\
231         n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
232         n2 =  (n3 & 0x00FF00FF)   + n4;\
233         SVQ1_ADD_CODEBOOK()\
234         /* store result */\
235         dst[x] = (n1 << 8) | n2;\
236         }\
237         dst += (pitch / 4);\
238       }
239
240 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
241       codebook = (const uint32_t *) cbook[level];\
242       bit_cache = get_bits (bitbuf, 4*stages);\
243       /* calculate codebook entries for this vector */\
244       for (j=0; j < stages; j++) {\
245         entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
246       }\
247       mean -= (stages * 128);\
248       n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
249
250 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
251   uint32_t    bit_cache;
252   uint8_t    *list[63];
253   uint32_t   *dst;
254   const uint32_t *codebook;
255   int         entries[6];
256   int         i, j, m, n;
257   int         mean, stages;
258   unsigned    x, y, width, height, level;
259   uint32_t    n1, n2, n3, n4;
260
261   /* initialize list for breadth first processing of vectors */
262   list[0] = pixels;
263
264   /* recursively process vector */
265   for (i=0, m=1, n=1, level=5; i < n; i++) {
266     SVQ1_PROCESS_VECTOR();
267
268     /* destination address and vector size */
269     dst = (uint32_t *) list[i];
270     width = 1 << ((4 + level) /2);
271     height = 1 << ((3 + level) /2);
272
273     /* get number of stages (-1 skips vector, 0 for mean only) */
274     stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
275
276     if (stages == -1) {
277         for (y=0; y < height; y++) {
278           memset (&dst[y*(pitch / 4)], 0, width);
279         }
280       continue;         /* skip vector */
281     }
282
283     if ((stages > 0) && (level >= 4)) {
284 #ifdef DEBUG_SVQ1
285     av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
286 #endif
287       return -1;        /* invalid vector */
288     }
289
290     mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
291
292     if (stages == 0) {
293       for (y=0; y < height; y++) {
294         memset (&dst[y*(pitch / 4)], mean, width);
295       }
296     } else {
297       SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
298       SVQ1_DO_CODEBOOK_INTRA()
299     }
300   }
301
302   return 0;
303 }
304
305 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
306   uint32_t    bit_cache;
307   uint8_t    *list[63];
308   uint32_t   *dst;
309   const uint32_t *codebook;
310   int         entries[6];
311   int         i, j, m, n;
312   int         mean, stages;
313   int         x, y, width, height, level;
314   uint32_t    n1, n2, n3, n4;
315
316   /* initialize list for breadth first processing of vectors */
317   list[0] = pixels;
318
319   /* recursively process vector */
320   for (i=0, m=1, n=1, level=5; i < n; i++) {
321     SVQ1_PROCESS_VECTOR();
322
323     /* destination address and vector size */
324     dst = (uint32_t *) list[i];
325     width = 1 << ((4 + level) /2);
326     height = 1 << ((3 + level) /2);
327
328     /* get number of stages (-1 skips vector, 0 for mean only) */
329     stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
330
331     if (stages == -1) continue; /* skip vector */
332
333     if ((stages > 0) && (level >= 4)) {
334 #ifdef DEBUG_SVQ1
335     av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
336 #endif
337       return -1;        /* invalid vector */
338     }
339
340     mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
341
342     SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
343     SVQ1_DO_CODEBOOK_NONINTRA()
344   }
345   return 0;
346 }
347
348 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
349   int         diff;
350   int         i;
351
352   for (i=0; i < 2; i++) {
353
354     /* get motion code */
355     diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
356     if(diff<0) 
357         return -1;
358     else if(diff){
359         if(get_bits1(bitbuf)) diff= -diff;
360     }
361
362     /* add median of motion vector predictors and clip result */
363     if (i == 1)
364       mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
365     else
366       mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
367   }
368
369   return 0;
370 }
371
372 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
373   uint8_t *src;
374   uint8_t *dst;
375   int      i;
376
377   src = &previous[x + y*pitch];
378   dst = current;
379
380   for (i=0; i < 16; i++) {
381     memcpy (dst, src, 16);
382     src += pitch;
383     dst += pitch;
384   }
385 }
386
387 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
388                                uint8_t *current, uint8_t *previous, int pitch,
389                                svq1_pmv_t *motion, int x, int y) {
390   uint8_t    *src;
391   uint8_t    *dst;
392   svq1_pmv_t  mv;
393   svq1_pmv_t *pmv[3];
394   int         result;
395
396   /* predict and decode motion vector */
397   pmv[0] = &motion[0];
398   if (y == 0) {
399     pmv[1] =
400     pmv[2] = pmv[0];
401   }
402   else {
403     pmv[1] = &motion[(x / 8) + 2];
404     pmv[2] = &motion[(x / 8) + 4];
405   }
406
407   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
408
409   if (result != 0)
410     return result;
411
412   motion[0].x           =
413   motion[(x / 8) + 2].x =
414   motion[(x / 8) + 3].x = mv.x;
415   motion[0].y           =
416   motion[(x / 8) + 2].y =
417   motion[(x / 8) + 3].y = mv.y;
418   
419   if(y + (mv.y >> 1)<0)
420      mv.y= 0;
421   if(x + (mv.x >> 1)<0)
422      mv.x= 0;
423
424 #if 0
425   int w= (s->width+15)&~15;
426   int h= (s->height+15)&~15;
427   if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
428       av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
429 #endif
430  
431   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
432   dst = current;
433
434   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
435
436   return 0;
437 }
438
439 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
440                                   uint8_t *current, uint8_t *previous, int pitch,
441                                   svq1_pmv_t *motion,int x, int y) {
442   uint8_t    *src;
443   uint8_t    *dst;
444   svq1_pmv_t  mv;
445   svq1_pmv_t *pmv[4];
446   int         i, result;
447
448   /* predict and decode motion vector (0) */
449   pmv[0] = &motion[0];
450   if (y == 0) {
451     pmv[1] =
452     pmv[2] = pmv[0];
453   }
454   else {
455     pmv[1] = &motion[(x / 8) + 2];
456     pmv[2] = &motion[(x / 8) + 4];
457   }
458
459   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
460
461   if (result != 0)
462     return result;
463
464   /* predict and decode motion vector (1) */
465   pmv[0] = &mv;
466   if (y == 0) {
467     pmv[1] =
468     pmv[2] = pmv[0];
469   }
470   else {
471     pmv[1] = &motion[(x / 8) + 3];
472   }
473   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
474
475   if (result != 0)
476     return result;
477
478   /* predict and decode motion vector (2) */
479   pmv[1] = &motion[0];
480   pmv[2] = &motion[(x / 8) + 1];
481
482   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
483
484   if (result != 0)
485     return result;
486
487   /* predict and decode motion vector (3) */
488   pmv[2] = &motion[(x / 8) + 2];
489   pmv[3] = &motion[(x / 8) + 3];
490
491   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
492
493   if (result != 0)
494     return result;
495
496   /* form predictions */
497   for (i=0; i < 4; i++) {
498     int mvx= pmv[i]->x + (i&1)*16;
499     int mvy= pmv[i]->y + (i>>1)*16;
500   
501     ///XXX /FIXME cliping or padding?
502     if(y + (mvy >> 1)<0)
503        mvy= 0;
504     if(x + (mvx >> 1)<0)
505        mvx= 0;
506
507 #if 0
508   int w= (s->width+15)&~15;
509   int h= (s->height+15)&~15;
510   if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
511       av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
512 #endif
513     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
514     dst = current;
515     
516     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
517
518     /* select next block */
519     if (i & 1) {
520       current  += 8*(pitch - 1);
521     } else {
522       current  += 8;
523     }
524   }
525
526   return 0;
527 }
528
529 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
530                         uint8_t *current, uint8_t *previous, int pitch,
531                         svq1_pmv_t *motion, int x, int y) {
532   uint32_t block_type;
533   int      result = 0;
534
535   /* get block type */
536   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
537
538   /* reset motion vectors */
539   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
540     motion[0].x           =
541     motion[0].y           =
542     motion[(x / 8) + 2].x =
543     motion[(x / 8) + 2].y =
544     motion[(x / 8) + 3].x =
545     motion[(x / 8) + 3].y = 0;
546   }
547
548   switch (block_type) {
549   case SVQ1_BLOCK_SKIP:
550     svq1_skip_block (current, previous, pitch, x, y);
551     break;
552
553   case SVQ1_BLOCK_INTER:
554     result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
555
556     if (result != 0)
557     {
558 #ifdef DEBUG_SVQ1
559     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
560 #endif
561       break;
562     }
563     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
564     break;
565
566   case SVQ1_BLOCK_INTER_4V:
567     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
568
569     if (result != 0)
570     {
571 #ifdef DEBUG_SVQ1
572     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
573 #endif
574       break;
575     }
576     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
577     break;
578
579   case SVQ1_BLOCK_INTRA:
580     result = svq1_decode_block_intra (bitbuf, current, pitch);
581     break;
582   }
583
584   return result;
585 }
586
587 /* standard video sizes */
588 static struct { int width; int height; } svq1_frame_size_table[8] = {
589   { 160, 120 }, { 128,  96 }, { 176, 144 }, { 352, 288 },
590   { 704, 576 }, { 240, 180 }, { 320, 240 }, {  -1,  -1 }
591 };
592
593 static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
594   int i;
595
596   for (i=0; i < length; i++) {
597     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
598   }
599
600   return value;
601 }
602
603 #if 0 /* unused, remove? */
604 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
605                                          int width, int height, int value) {
606   int x, y;
607
608   for (y=0; y < height; y++) {
609     for (x=0; x < width; x++) {
610       value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
611     }
612
613     pixels += pitch;
614   }
615
616   return value;
617 }
618 #endif
619
620 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
621   uint8_t seed;
622   int     i;
623
624   out[0] = get_bits (bitbuf, 8);
625
626   seed = string_table[out[0]];
627
628   for (i=1; i <= out[0]; i++) {
629     out[i] = get_bits (bitbuf, 8) ^ seed;
630     seed   = string_table[out[i] ^ seed];
631   }
632 }
633
634 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
635   int frame_size_code;
636   int temporal_reference;
637
638   temporal_reference = get_bits (bitbuf, 8);
639
640   /* frame type */
641   s->pict_type= get_bits (bitbuf, 2)+1;
642   if(s->pict_type==4) 
643       return -1;
644       
645   if (s->pict_type == I_TYPE) {
646
647     /* unknown fields */
648     if (s->f_code == 0x50 || s->f_code == 0x60) {
649       int csum = get_bits (bitbuf, 16);
650
651       csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
652
653 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
654 //              (csum == 0) ? "correct" : "incorrect", csum);
655     }
656
657     if ((s->f_code ^ 0x10) >= 0x50) {
658       char msg[256];
659
660       svq1_parse_string (bitbuf, (char *) msg);
661
662       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
663     }
664
665     skip_bits (bitbuf, 2);
666     skip_bits (bitbuf, 2);
667     skip_bits1 (bitbuf);
668
669     /* load frame size */
670     frame_size_code = get_bits (bitbuf, 3);
671
672     if (frame_size_code == 7) {
673       /* load width, height (12 bits each) */
674       s->width = get_bits (bitbuf, 12);
675       s->height = get_bits (bitbuf, 12);
676
677       if (!s->width || !s->height)
678         return -1;
679     } else {
680       /* get width, height from table */
681       s->width = svq1_frame_size_table[frame_size_code].width;
682       s->height = svq1_frame_size_table[frame_size_code].height;
683     }
684   }
685
686   /* unknown fields */
687   if (get_bits (bitbuf, 1) == 1) {
688     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
689     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
690
691     if (get_bits (bitbuf, 2) != 0)
692       return -1;
693   }
694
695   if (get_bits (bitbuf, 1) == 1) {
696     skip_bits1 (bitbuf);
697     skip_bits (bitbuf, 4);
698     skip_bits1 (bitbuf);
699     skip_bits (bitbuf, 2);
700
701     while (get_bits (bitbuf, 1) == 1) {
702       skip_bits (bitbuf, 8);
703     }
704   }
705   
706   return 0;
707 }
708
709 static int svq1_decode_frame(AVCodecContext *avctx, 
710                              void *data, int *data_size,
711                              uint8_t *buf, int buf_size)
712 {
713   MpegEncContext *s=avctx->priv_data;
714   uint8_t      *current, *previous;
715   int           result, i, x, y, width, height;
716   AVFrame *pict = data; 
717
718   /* initialize bit buffer */
719   init_get_bits(&s->gb,buf,buf_size*8);
720
721   /* decode frame header */
722   s->f_code = get_bits (&s->gb, 22);
723
724   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
725     return -1;
726
727   /* swap some header bytes (why?) */
728   if (s->f_code != 0x20) {
729     uint32_t *src = (uint32_t *) (buf + 4);
730
731     for (i=0; i < 4; i++) {
732       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
733     }
734   }
735
736   result = svq1_decode_frame_header (&s->gb, s);
737
738   if (result != 0)
739   {
740 #ifdef DEBUG_SVQ1
741     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
742 #endif
743     return result;
744   }
745   
746   //FIXME this avoids some confusion for "B frames" without 2 references
747   //this should be removed after libavcodec can handle more flexible picture types & ordering
748   if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
749   
750   if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
751
752   if(MPV_frame_start(s, avctx) < 0)
753       return -1;
754
755   /* decode y, u and v components */
756   for (i=0; i < 3; i++) {
757     int linesize;
758     if (i == 0) {
759       width  = (s->width+15)&~15;
760       height = (s->height+15)&~15;
761       linesize= s->linesize;
762     } else {
763       if(s->flags&CODEC_FLAG_GRAY) break;
764       width  = (s->width/4+15)&~15;
765       height = (s->height/4+15)&~15;
766       linesize= s->uvlinesize;
767     }
768
769     current  = s->current_picture.data[i];
770
771     if(s->pict_type==B_TYPE){
772         previous = s->next_picture.data[i];
773     }else{
774         previous = s->last_picture.data[i];
775     }
776
777     if (s->pict_type == I_TYPE) {
778       /* keyframe */
779       for (y=0; y < height; y+=16) {
780         for (x=0; x < width; x+=16) {
781           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
782           if (result != 0)
783           {
784 //#ifdef DEBUG_SVQ1
785             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
786 //#endif
787             return result;
788           }
789         }
790         current += 16*linesize;
791       }
792     } else {
793       svq1_pmv_t pmv[width/8+3];
794       /* delta frame */
795       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
796
797       for (y=0; y < height; y+=16) {
798         for (x=0; x < width; x+=16) {
799           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
800                                             linesize, pmv, x, y);
801           if (result != 0)
802           {
803 #ifdef DEBUG_SVQ1
804     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
805 #endif
806             return result;
807           }
808         }
809
810         pmv[0].x =
811         pmv[0].y = 0;
812
813         current += 16*linesize;
814       }
815     }
816   }
817   
818   *pict = *(AVFrame*)&s->current_picture;
819
820
821   MPV_frame_end(s);
822   
823   *data_size=sizeof(AVFrame);
824   return buf_size;
825 }
826
827 static int svq1_decode_init(AVCodecContext *avctx)
828 {
829     MpegEncContext *s = avctx->priv_data;
830     int i;
831
832     MPV_decode_defaults(s);
833
834     s->avctx = avctx;
835     s->width = (avctx->width+3)&~3;
836     s->height = (avctx->height+3)&~3;
837     s->codec_id= avctx->codec->id;
838     avctx->pix_fmt = PIX_FMT_YUV410P;
839     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
840     s->flags= avctx->flags;
841     if (MPV_common_init(s) < 0) return -1;
842
843     init_vlc(&svq1_block_type, 2, 4,
844         &svq1_block_type_vlc[0][1], 2, 1,
845         &svq1_block_type_vlc[0][0], 2, 1, 1);
846
847     init_vlc(&svq1_motion_component, 7, 33,
848         &mvtab[0][1], 2, 1,
849         &mvtab[0][0], 2, 1, 1);
850
851     for (i = 0; i < 6; i++) {
852         init_vlc(&svq1_intra_multistage[i], 3, 8,
853             &svq1_intra_multistage_vlc[i][0][1], 2, 1,
854             &svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
855         init_vlc(&svq1_inter_multistage[i], 3, 8,
856             &svq1_inter_multistage_vlc[i][0][1], 2, 1,
857             &svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
858     }
859
860     init_vlc(&svq1_intra_mean, 8, 256,
861         &svq1_intra_mean_vlc[0][1], 4, 2,
862         &svq1_intra_mean_vlc[0][0], 4, 2, 1);
863
864     init_vlc(&svq1_inter_mean, 9, 512,
865         &svq1_inter_mean_vlc[0][1], 4, 2,
866         &svq1_inter_mean_vlc[0][0], 4, 2, 1);
867
868     return 0;
869 }
870
871 static int svq1_decode_end(AVCodecContext *avctx)
872 {
873     MpegEncContext *s = avctx->priv_data;
874
875     MPV_common_end(s);
876     return 0;
877 }
878
879 static void svq1_write_header(SVQ1Context *s, int frame_type)
880 {
881     int i;
882
883     /* frame code */
884     put_bits(&s->pb, 22, 0x20);
885
886     /* temporal reference (sure hope this is a "don't care") */
887     put_bits(&s->pb, 8, 0x00);
888
889     /* frame type */
890     put_bits(&s->pb, 2, frame_type - 1);
891
892     if (frame_type == I_TYPE) {
893
894         /* no checksum since frame code is 0x20 */
895
896         /* no embedded string either */
897
898         /* output 5 unknown bits (2 + 2 + 1) */
899         put_bits(&s->pb, 5, 0);
900
901         for (i = 0; i < 7; i++)
902         {
903             if ((svq1_frame_size_table[i].width == s->frame_width) &&
904                 (svq1_frame_size_table[i].height == s->frame_height))
905             {
906                 put_bits(&s->pb, 3, i);
907                 break;
908             }
909         }
910         
911         if (i == 7)
912         {
913             put_bits(&s->pb, 3, 7);
914             put_bits(&s->pb, 12, s->frame_width);
915             put_bits(&s->pb, 12, s->frame_height);
916         }
917     }
918
919     /* no checksum or extra data (next 2 bits get 0) */
920     put_bits(&s->pb, 2, 0);
921 }
922
923
924 #define QUALITY_THRESHOLD 100
925 #define THRESHOLD_MULTIPLIER 0.6
926
927 #if defined(HAVE_ALTIVEC)
928 #undef vector
929 #endif
930
931 static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){
932     int count, y, x, i, j, split, best_mean, best_score, best_count;
933     int best_vector[6];
934     int block_sum[7]= {0, 0, 0, 0, 0, 0};
935     int w= 2<<((level+2)>>1);
936     int h= 2<<((level+1)>>1);
937     int size=w*h;
938     int16_t block[7][256];
939     const int8_t *codebook_sum, *codebook;
940     const uint16_t (*mean_vlc)[2];
941     const uint8_t (*multistage_vlc)[2];
942
943     best_score=0;
944     //FIXME optimize, this doenst need to be done multiple times
945     if(intra){
946         codebook_sum= svq1_intra_codebook_sum[level];
947         codebook= svq1_intra_codebooks[level];
948         mean_vlc= svq1_intra_mean_vlc;
949         multistage_vlc= svq1_intra_multistage_vlc[level];
950         for(y=0; y<h; y++){
951             for(x=0; x<w; x++){
952                 int v= src[x + y*stride];
953                 block[0][x + w*y]= v;
954                 best_score += v*v;
955                 block_sum[0] += v;
956             }
957         }
958     }else{
959         codebook_sum= svq1_inter_codebook_sum[level];
960         codebook= svq1_inter_codebooks[level];
961         mean_vlc= svq1_inter_mean_vlc + 256;
962         multistage_vlc= svq1_inter_multistage_vlc[level];
963         for(y=0; y<h; y++){
964             for(x=0; x<w; x++){
965                 int v= src[x + y*stride] - ref[x + y*stride];
966                 block[0][x + w*y]= v;
967                 best_score += v*v;
968                 block_sum[0] += v;
969             }
970         }
971     }
972
973     best_count=0;
974     best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
975     best_mean= (block_sum[0] + (size>>1)) >> (level+3);
976
977     if(level<4){
978         for(count=1; count<7; count++){
979             int best_vector_score= INT_MAX;
980             int best_vector_sum=-999, best_vector_mean=-999;
981             const int stage= count-1;
982             const int8_t *vector;
983     
984             for(i=0; i<16; i++){
985                 int sum= codebook_sum[stage*16 + i];
986                 int sqr=0;
987                 int diff, mean, score;
988     
989                 vector = codebook + stage*size*16 + i*size;
990     
991                 for(j=0; j<size; j++){
992                     int v= vector[j];
993                     sqr += (v - block[stage][j])*(v - block[stage][j]);
994                 }
995                 diff= block_sum[stage] - sum;
996                 mean= (diff + (size>>1)) >> (level+3);
997                 assert(mean >-300 && mean<300);
998                 if(intra) mean= clip(mean, 0, 255);
999                 else      mean= clip(mean, -256, 255);
1000                 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1001                 if(score < best_vector_score){
1002                     best_vector_score= score;
1003                     best_vector[stage]= i;
1004                     best_vector_sum= sum;
1005                     best_vector_mean= mean;
1006                 }
1007             }
1008             assert(best_vector_mean != -999);
1009             vector= codebook + stage*size*16 + best_vector[stage]*size;
1010             for(j=0; j<size; j++){
1011                 block[stage+1][j] = block[stage][j] - vector[j];
1012             }
1013             block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1014             best_vector_score += 
1015                 lambda*(+ 1 + 4*count
1016                         + multistage_vlc[1+count][1]
1017                         + mean_vlc[best_vector_mean][1]);
1018     
1019             if(best_vector_score < best_score){
1020                 best_score= best_vector_score;
1021                 best_count= count;
1022                 best_mean= best_vector_mean;
1023             }
1024         }
1025     }
1026     
1027     split=0;
1028     if(best_score > threshold && level){
1029         int score=0;
1030         int offset= (level&1) ? stride*h/2 : w/2;
1031         PutBitContext backup[6];
1032
1033         for(i=level-1; i>=0; i--){
1034             backup[i]= s->reorder_pb[i];
1035         }
1036         score += encode_block(s, src         , ref         , decoded         , stride, level-1, threshold>>1, lambda, intra);
1037         score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1038         score += lambda;
1039         
1040         if(score < best_score){
1041             best_score= score;
1042             split=1;
1043         }else{
1044             for(i=level-1; i>=0; i--){
1045                 s->reorder_pb[i]= backup[i];
1046             }
1047         }
1048     }
1049     if (level > 0)
1050         put_bits(&s->reorder_pb[level], 1, split);
1051
1052     if(!split){
1053         assert((best_mean >= 0 && best_mean<256) || !intra);
1054         assert(best_mean >= -256 && best_mean<256);
1055         assert(best_count >=0 && best_count<7);
1056         assert(level<4 || best_count==0);
1057             
1058         /* output the encoding */
1059         put_bits(&s->reorder_pb[level], 
1060             multistage_vlc[1 + best_count][1],
1061             multistage_vlc[1 + best_count][0]);
1062         put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1063             mean_vlc[best_mean][0]);
1064
1065         for (i = 0; i < best_count; i++){
1066             assert(best_vector[i]>=0 && best_vector[i]<16);
1067             put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1068         }
1069         
1070         for(y=0; y<h; y++){
1071             for(x=0; x<w; x++){
1072                 decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1073             }
1074         }
1075     }
1076
1077     return best_score;
1078 }
1079
1080 #ifdef CONFIG_ENCODERS
1081
1082 static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1083     int width, int height, int src_stride, int stride)
1084 {
1085     int x, y;
1086     int i;
1087     int block_width, block_height;
1088     int level;
1089     int threshold[6];
1090     const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1091
1092     /* figure out the acceptable level thresholds in advance */
1093     threshold[5] = QUALITY_THRESHOLD;
1094     for (level = 4; level >= 0; level--)
1095         threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1096
1097     block_width = (width + 15) / 16;
1098     block_height = (height + 15) / 16;
1099
1100     if(s->picture.pict_type == P_TYPE){
1101         s->m.avctx= s->avctx;
1102         s->m.current_picture_ptr= &s->m.current_picture;
1103         s->m.last_picture_ptr   = &s->m.last_picture;
1104         s->m.last_picture.data[0]= ref_plane;
1105         s->m.linesize=
1106         s->m.last_picture.linesize[0]= 
1107         s->m.new_picture.linesize[0]= 
1108         s->m.current_picture.linesize[0]= stride;
1109         s->m.width= width;
1110         s->m.height= height;
1111         s->m.mb_width= block_width;
1112         s->m.mb_height= block_height;
1113         s->m.mb_stride= s->m.mb_width+1;
1114         s->m.b8_stride= 2*s->m.mb_width+1;
1115         s->m.f_code=1;
1116         s->m.pict_type= s->picture.pict_type;
1117         s->m.qscale= s->picture.quality/FF_QP2LAMBDA;
1118         s->m.me_method= s->avctx->me_method;
1119         
1120         if(!s->motion_val8[plane]){
1121             s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1122             s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1123         }
1124
1125         s->m.mb_type= s->mb_type;
1126         
1127         //dummies, to avoid segfaults
1128         s->m.current_picture.mb_mean=   (uint8_t *)s->dummy;
1129         s->m.current_picture.mb_var=    (uint16_t*)s->dummy;
1130         s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1131         s->m.current_picture.mb_type= s->dummy;
1132         
1133         s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1134         s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1135         s->m.dsp= s->dsp; //move
1136         ff_init_me(&s->m);
1137     
1138         s->m.me.dia_size= s->avctx->dia_size;
1139         s->m.first_slice_line=1;
1140         for (y = 0; y < block_height; y++) {
1141             uint8_t src[stride*16];
1142             
1143             s->m.new_picture.data[0]= src - y*16*stride; //ugly
1144             s->m.mb_y= y;
1145     
1146             for(i=0; i<16 && i + 16*y<height; i++){
1147                 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1148                 for(x=width; x<16*block_width; x++)
1149                     src[i*stride+x]= src[i*stride+x-1];
1150             }
1151             for(; i<16 && i + 16*y<16*block_height; i++)
1152                 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1153     
1154             for (x = 0; x < block_width; x++) {
1155                 s->m.mb_x= x;
1156                 ff_init_block_index(&s->m);
1157                 ff_update_block_index(&s->m);
1158                 
1159                 ff_estimate_p_frame_motion(&s->m, x, y);
1160             }
1161             s->m.first_slice_line=0;
1162         }
1163     
1164         ff_fix_long_p_mvs(&s->m);
1165         ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1166     }
1167         
1168     s->m.first_slice_line=1;
1169     for (y = 0; y < block_height; y++) {
1170         uint8_t src[stride*16];
1171         
1172         for(i=0; i<16 && i + 16*y<height; i++){
1173             memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1174             for(x=width; x<16*block_width; x++)
1175                 src[i*stride+x]= src[i*stride+x-1];
1176         }
1177         for(; i<16 && i + 16*y<16*block_height; i++)
1178             memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1179
1180         s->m.mb_y= y;
1181         for (x = 0; x < block_width; x++) {
1182             uint8_t reorder_buffer[3][6][7*32];
1183             int count[3][6];
1184             int offset = y * 16 * stride + x * 16;
1185             uint8_t *decoded= decoded_plane + offset;
1186             uint8_t *ref= ref_plane + offset;
1187             int score[4]={0,0,0,0}, best;
1188             uint8_t temp[16*stride];
1189             
1190             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
1191                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1192                 return -1;
1193             }
1194
1195             s->m.mb_x= x;
1196             ff_init_block_index(&s->m);
1197             ff_update_block_index(&s->m);
1198             
1199             if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1200                 for(i=0; i<6; i++){
1201                     init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1202                 }
1203                 if(s->picture.pict_type == P_TYPE){
1204                     const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1205                     put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1206                     score[0]= vlc[1]*lambda;
1207                 }
1208                 score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1209                 for(i=0; i<6; i++){
1210                     count[0][i]= put_bits_count(&s->reorder_pb[i]);
1211                     flush_put_bits(&s->reorder_pb[i]);
1212                 }
1213             }else
1214                 score[0]= INT_MAX;
1215             
1216             best=0;
1217             
1218             if(s->picture.pict_type == P_TYPE){
1219                 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1220                 int mx, my, pred_x, pred_y, dxy;
1221                 int16_t *motion_ptr;
1222
1223                 motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1224                 if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1225                     for(i=0; i<6; i++)
1226                         init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1227
1228                     put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1229     
1230                     s->m.pb= s->reorder_pb[5];                
1231                     mx= motion_ptr[0];
1232                     my= motion_ptr[1];
1233                     assert(mx>=-32 && mx<=31);
1234                     assert(my>=-32 && my<=31);
1235                     assert(pred_x>=-32 && pred_x<=31);
1236                     assert(pred_y>=-32 && pred_y<=31);
1237                     ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1238                     ff_h263_encode_motion(&s->m, my - pred_y, 1);
1239                     s->reorder_pb[5]= s->m.pb;
1240                     score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1241     
1242                     dxy= (mx&1) + 2*(my&1);
1243                     
1244                     s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1245                     
1246                     score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1247                     best= score[1] <= score[0];
1248
1249                     vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1250                     score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1251                     score[2]+= vlc[1]*lambda;
1252                     if(score[2] < score[best] && mx==0 && my==0){
1253                         best=2;
1254                         s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1255                         for(i=0; i<6; i++){
1256                             count[2][i]=0;
1257                         }
1258                         put_bits(&s->pb, vlc[1], vlc[0]);
1259                     }
1260                 }
1261
1262                 if(best==1){
1263                     for(i=0; i<6; i++){
1264                         count[1][i]= put_bits_count(&s->reorder_pb[i]);
1265                         flush_put_bits(&s->reorder_pb[i]);
1266                     }
1267                 }else{
1268                     motion_ptr[0                 ] = motion_ptr[1                 ]=
1269                     motion_ptr[2                 ] = motion_ptr[3                 ]=
1270                     motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1271                     motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1272                 }
1273             }
1274                 
1275             s->rd_total += score[best];
1276
1277             for(i=5; i>=0; i--){
1278                 ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1279             }
1280             if(best==0){
1281                 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1282             }
1283         }
1284         s->m.first_slice_line=0;
1285     }
1286     return 0;
1287 }
1288
1289 static int svq1_encode_init(AVCodecContext *avctx)
1290 {
1291     SVQ1Context * const s = avctx->priv_data;
1292
1293     dsputil_init(&s->dsp, avctx);
1294     avctx->coded_frame= (AVFrame*)&s->picture;
1295
1296     s->frame_width = avctx->width;
1297     s->frame_height = avctx->height;
1298
1299     s->y_block_width = (s->frame_width + 15) / 16;
1300     s->y_block_height = (s->frame_height + 15) / 16;
1301
1302     s->c_block_width = (s->frame_width / 4 + 15) / 16;
1303     s->c_block_height = (s->frame_height / 4 + 15) / 16;
1304
1305     s->avctx= avctx;
1306     s->m.avctx= avctx;
1307     s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t)); 
1308     s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1309     s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1310     s->mb_type        = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1311     s->dummy          = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1312     h263_encode_init(&s->m); //mv_penalty
1313     
1314     return 0;
1315 }
1316
1317 static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf, 
1318     int buf_size, void *data)
1319 {
1320     SVQ1Context * const s = avctx->priv_data;
1321     AVFrame *pict = data;
1322     AVFrame * const p= (AVFrame*)&s->picture;
1323     AVFrame temp;
1324     int i;
1325
1326     if(avctx->pix_fmt != PIX_FMT_YUV410P){
1327         av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1328         return -1;
1329     }
1330     
1331     if(!s->current_picture.data[0]){
1332         avctx->get_buffer(avctx, &s->current_picture);
1333         avctx->get_buffer(avctx, &s->last_picture);
1334     }
1335     
1336     temp= s->current_picture;
1337     s->current_picture= s->last_picture;
1338     s->last_picture= temp;
1339     
1340     init_put_bits(&s->pb, buf, buf_size);
1341
1342     *p = *pict;
1343     p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1344     p->key_frame = p->pict_type == I_TYPE;
1345
1346     svq1_write_header(s, p->pict_type);
1347     for(i=0; i<3; i++){
1348         if(svq1_encode_plane(s, i,
1349             s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1350             s->frame_width / (i?4:1), s->frame_height / (i?4:1), 
1351             s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
1352                 return -1;
1353     }
1354
1355 //    align_put_bits(&s->pb);
1356     while(put_bits_count(&s->pb) & 31)
1357         put_bits(&s->pb, 1, 0);
1358         
1359     flush_put_bits(&s->pb);
1360
1361     return (put_bits_count(&s->pb) / 8);
1362 }
1363
1364 static int svq1_encode_end(AVCodecContext *avctx)
1365 {
1366     SVQ1Context * const s = avctx->priv_data;
1367     int i;
1368
1369     av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1370     
1371     av_freep(&s->m.me.scratchpad);     
1372     av_freep(&s->m.me.map);
1373     av_freep(&s->m.me.score_map);
1374     av_freep(&s->mb_type);
1375     av_freep(&s->dummy);
1376
1377     for(i=0; i<3; i++){
1378         av_freep(&s->motion_val8[i]);
1379         av_freep(&s->motion_val16[i]);
1380     }
1381
1382     return 0;
1383 }
1384
1385 #endif //CONFIG_ENCODERS
1386
1387 AVCodec svq1_decoder = {
1388     "svq1",
1389     CODEC_TYPE_VIDEO,
1390     CODEC_ID_SVQ1,
1391     sizeof(MpegEncContext),
1392     svq1_decode_init,
1393     NULL,
1394     svq1_decode_end,
1395     svq1_decode_frame,
1396     CODEC_CAP_DR1,
1397     .flush= ff_mpeg_flush,
1398     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1399 };
1400
1401 #ifdef CONFIG_ENCODERS
1402
1403 AVCodec svq1_encoder = {
1404     "svq1",
1405     CODEC_TYPE_VIDEO,
1406     CODEC_ID_SVQ1,
1407     sizeof(SVQ1Context),
1408     svq1_encode_init,
1409     svq1_encode_frame,
1410     svq1_encode_end,
1411     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1412 };
1413
1414 #endif //CONFIG_ENCODERS