p frame encoding, only with 0,0 motion vectors yet though
[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 static VLC svq1_block_type;
52 static VLC svq1_motion_component;
53 static VLC svq1_intra_multistage[6];
54 static VLC svq1_inter_multistage[6];
55 static VLC svq1_intra_mean;
56 static VLC svq1_inter_mean;
57
58 #define MEDIAN(a,b,c)   (((a < b) != (b >= c)) ? b : (((a < c) != (c > b)) ? c : a))
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
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     unsigned char *c_plane;
89
90     int64_t rd_total;
91 } SVQ1Context;
92
93 /* motion vector (prediction) */
94 typedef struct svq1_pmv_s {
95   int            x;
96   int            y;
97 } svq1_pmv_t;
98
99 #include "svq1_cb.h"
100 #include "svq1_vlc.h"
101
102 static const uint16_t checksum_table[256] = {
103   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
104   0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
105   0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
106   0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
107   0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
108   0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
109   0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
110   0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
111   0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
112   0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
113   0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
114   0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
115   0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
116   0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
117   0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
118   0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
119   0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
120   0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
121   0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
122   0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
123   0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
124   0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
125   0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
126   0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
127   0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
128   0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
129   0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
130   0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
131   0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
132   0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
133   0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
134   0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
135 };
136
137 static const uint8_t string_table[256] = {
138   0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
139   0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
140   0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
141   0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
142   0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
143   0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
144   0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
145   0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
146   0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
147   0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
148   0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
149   0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
150   0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
151   0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
152   0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
153   0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
154   0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
155   0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
156   0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
157   0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
158   0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
159   0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
160   0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
161   0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
162   0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
163   0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
164   0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
165   0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
166   0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
167   0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
168   0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
169   0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
170 };
171
172 #define SVQ1_PROCESS_VECTOR()\
173     for (; level > 0; i++) {\
174       /* process next depth */\
175       if (i == m) {\
176         m = n;\
177         if (--level == 0)\
178           break;\
179       }\
180       /* divide block if next bit set */\
181       if (get_bits (bitbuf, 1) == 0)\
182         break;\
183       /* add child nodes */\
184       list[n++] = list[i];\
185       list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
186     }
187
188 #define SVQ1_ADD_CODEBOOK()\
189           /* add codebook entries to vector */\
190           for (j=0; j < stages; j++) {\
191             n3  = codebook[entries[j]] ^ 0x80808080;\
192             n1 += ((n3 & 0xFF00FF00) >> 8);\
193             n2 +=  (n3 & 0x00FF00FF);\
194           }\
195 \
196           /* clip to [0..255] */\
197           if (n1 & 0xFF00FF00) {\
198             n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
199             n1 += 0x7F007F00;\
200             n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
201             n1 &= (n3 & 0x00FF00FF);\
202           }\
203 \
204           if (n2 & 0xFF00FF00) {\
205             n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
206             n2 += 0x7F007F00;\
207             n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
208             n2 &= (n3 & 0x00FF00FF);\
209           }
210
211 #define SVQ1_DO_CODEBOOK_INTRA()\
212       for (y=0; y < height; y++) {\
213         for (x=0; x < (width / 4); x++, codebook++) {\
214         n1 = n4;\
215         n2 = n4;\
216         SVQ1_ADD_CODEBOOK()\
217         /* store result */\
218         dst[x] = (n1 << 8) | n2;\
219         }\
220         dst += (pitch / 4);\
221       }
222
223 #define SVQ1_DO_CODEBOOK_NONINTRA()\
224       for (y=0; y < height; y++) {\
225         for (x=0; x < (width / 4); x++, codebook++) {\
226         n3 = dst[x];\
227         /* add mean value to vector */\
228         n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
229         n2 =  (n3 & 0x00FF00FF)   + n4;\
230         SVQ1_ADD_CODEBOOK()\
231         /* store result */\
232         dst[x] = (n1 << 8) | n2;\
233         }\
234         dst += (pitch / 4);\
235       }
236
237 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
238       codebook = (const uint32_t *) cbook[level];\
239       bit_cache = get_bits (bitbuf, 4*stages);\
240       /* calculate codebook entries for this vector */\
241       for (j=0; j < stages; j++) {\
242         entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
243       }\
244       mean -= (stages * 128);\
245       n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
246
247 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
248   uint32_t    bit_cache;
249   uint8_t    *list[63];
250   uint32_t   *dst;
251   const uint32_t *codebook;
252   int         entries[6];
253   int         i, j, m, n;
254   int         mean, stages;
255   unsigned    x, y, width, height, level;
256   uint32_t    n1, n2, n3, n4;
257
258   /* initialize list for breadth first processing of vectors */
259   list[0] = pixels;
260
261   /* recursively process vector */
262   for (i=0, m=1, n=1, level=5; i < n; i++) {
263     SVQ1_PROCESS_VECTOR();
264
265     /* destination address and vector size */
266     dst = (uint32_t *) list[i];
267     width = 1 << ((4 + level) /2);
268     height = 1 << ((3 + level) /2);
269
270     /* get number of stages (-1 skips vector, 0 for mean only) */
271     stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
272
273     if (stages == -1) {
274         for (y=0; y < height; y++) {
275           memset (&dst[y*(pitch / 4)], 0, width);
276         }
277       continue;         /* skip vector */
278     }
279
280     if ((stages > 0) && (level >= 4)) {
281 #ifdef DEBUG_SVQ1
282     av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
283 #endif
284       return -1;        /* invalid vector */
285     }
286
287     mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
288
289     if (stages == 0) {
290       for (y=0; y < height; y++) {
291         memset (&dst[y*(pitch / 4)], mean, width);
292       }
293     } else {
294       SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
295       SVQ1_DO_CODEBOOK_INTRA()
296     }
297   }
298
299   return 0;
300 }
301
302 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
303   uint32_t    bit_cache;
304   uint8_t    *list[63];
305   uint32_t   *dst;
306   const uint32_t *codebook;
307   int         entries[6];
308   int         i, j, m, n;
309   int         mean, stages;
310   int         x, y, width, height, level;
311   uint32_t    n1, n2, n3, n4;
312
313   /* initialize list for breadth first processing of vectors */
314   list[0] = pixels;
315
316   /* recursively process vector */
317   for (i=0, m=1, n=1, level=5; i < n; i++) {
318     SVQ1_PROCESS_VECTOR();
319
320     /* destination address and vector size */
321     dst = (uint32_t *) list[i];
322     width = 1 << ((4 + level) /2);
323     height = 1 << ((3 + level) /2);
324
325     /* get number of stages (-1 skips vector, 0 for mean only) */
326     stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
327
328     if (stages == -1) continue; /* skip vector */
329
330     if ((stages > 0) && (level >= 4)) {
331 #ifdef DEBUG_SVQ1
332     av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
333 #endif
334       return -1;        /* invalid vector */
335     }
336
337     mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
338
339     SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
340     SVQ1_DO_CODEBOOK_NONINTRA()
341   }
342   return 0;
343 }
344
345 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
346   int         diff;
347   int         i;
348
349   for (i=0; i < 2; i++) {
350
351     /* get motion code */
352     diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2) - 32;
353
354     /* add median of motion vector predictors and clip result */
355     if (i == 1)
356       mv->y = ((diff + MEDIAN(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
357     else
358       mv->x = ((diff + MEDIAN(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
359   }
360
361   return 0;
362 }
363
364 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
365   uint8_t *src;
366   uint8_t *dst;
367   int      i;
368
369   src = &previous[x + y*pitch];
370   dst = current;
371
372   for (i=0; i < 16; i++) {
373     memcpy (dst, src, 16);
374     src += pitch;
375     dst += pitch;
376   }
377 }
378
379 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
380                                uint8_t *current, uint8_t *previous, int pitch,
381                                svq1_pmv_t *motion, int x, int y) {
382   uint8_t    *src;
383   uint8_t    *dst;
384   svq1_pmv_t  mv;
385   svq1_pmv_t *pmv[3];
386   int         result;
387
388   /* predict and decode motion vector */
389   pmv[0] = &motion[0];
390   if (y == 0) {
391     pmv[1] =
392     pmv[2] = pmv[0];
393   }
394   else {
395     pmv[1] = &motion[(x / 8) + 2];
396     pmv[2] = &motion[(x / 8) + 4];
397   }
398
399   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
400
401   if (result != 0)
402     return result;
403
404   motion[0].x           =
405   motion[(x / 8) + 2].x =
406   motion[(x / 8) + 3].x = mv.x;
407   motion[0].y           =
408   motion[(x / 8) + 2].y =
409   motion[(x / 8) + 3].y = mv.y;
410   
411   if(y + (mv.y >> 1)<0)
412      mv.y= 0;
413   if(x + (mv.x >> 1)<0)
414      mv.x= 0;
415
416 #if 0
417   int w= (s->width+15)&~15;
418   int h= (s->height+15)&~15;
419   if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
420       av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
421 #endif
422  
423   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
424   dst = current;
425
426   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
427
428   return 0;
429 }
430
431 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
432                                   uint8_t *current, uint8_t *previous, int pitch,
433                                   svq1_pmv_t *motion,int x, int y) {
434   uint8_t    *src;
435   uint8_t    *dst;
436   svq1_pmv_t  mv;
437   svq1_pmv_t *pmv[4];
438   int         i, result;
439
440   /* predict and decode motion vector (0) */
441   pmv[0] = &motion[0];
442   if (y == 0) {
443     pmv[1] =
444     pmv[2] = pmv[0];
445   }
446   else {
447     pmv[1] = &motion[(x / 8) + 2];
448     pmv[2] = &motion[(x / 8) + 4];
449   }
450
451   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
452
453   if (result != 0)
454     return result;
455
456   /* predict and decode motion vector (1) */
457   pmv[0] = &mv;
458   if (y == 0) {
459     pmv[1] =
460     pmv[2] = pmv[0];
461   }
462   else {
463     pmv[1] = &motion[(x / 8) + 3];
464   }
465   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
466
467   if (result != 0)
468     return result;
469
470   /* predict and decode motion vector (2) */
471   pmv[1] = &motion[0];
472   pmv[2] = &motion[(x / 8) + 1];
473
474   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
475
476   if (result != 0)
477     return result;
478
479   /* predict and decode motion vector (3) */
480   pmv[2] = &motion[(x / 8) + 2];
481   pmv[3] = &motion[(x / 8) + 3];
482
483   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
484
485   if (result != 0)
486     return result;
487
488   /* form predictions */
489   for (i=0; i < 4; i++) {
490     int mvx= pmv[i]->x + (i&1)*16;
491     int mvy= pmv[i]->y + (i>>1)*16;
492   
493     ///XXX /FIXME cliping or padding?
494     if(y + (mvy >> 1)<0)
495        mvy= 0;
496     if(x + (mvx >> 1)<0)
497        mvx= 0;
498
499 #if 0
500   int w= (s->width+15)&~15;
501   int h= (s->height+15)&~15;
502   if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
503       av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
504 #endif
505     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
506     dst = current;
507     
508     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
509
510     /* select next block */
511     if (i & 1) {
512       current  += 8*(pitch - 1);
513     } else {
514       current  += 8;
515     }
516   }
517
518   return 0;
519 }
520
521 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
522                         uint8_t *current, uint8_t *previous, int pitch,
523                         svq1_pmv_t *motion, int x, int y) {
524   uint32_t block_type;
525   int      result = 0;
526
527   /* get block type */
528   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
529
530   /* reset motion vectors */
531   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
532     motion[0].x           =
533     motion[0].y           =
534     motion[(x / 8) + 2].x =
535     motion[(x / 8) + 2].y =
536     motion[(x / 8) + 3].x =
537     motion[(x / 8) + 3].y = 0;
538   }
539
540   switch (block_type) {
541   case SVQ1_BLOCK_SKIP:
542     svq1_skip_block (current, previous, pitch, x, y);
543     break;
544
545   case SVQ1_BLOCK_INTER:
546     result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
547
548     if (result != 0)
549     {
550 #ifdef DEBUG_SVQ1
551     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
552 #endif
553       break;
554     }
555     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
556     break;
557
558   case SVQ1_BLOCK_INTER_4V:
559     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
560
561     if (result != 0)
562     {
563 #ifdef DEBUG_SVQ1
564     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
565 #endif
566       break;
567     }
568     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
569     break;
570
571   case SVQ1_BLOCK_INTRA:
572     result = svq1_decode_block_intra (bitbuf, current, pitch);
573     break;
574   }
575
576   return result;
577 }
578
579 /* standard video sizes */
580 static struct { int width; int height; } svq1_frame_size_table[8] = {
581   { 160, 120 }, { 128,  96 }, { 176, 144 }, { 352, 288 },
582   { 704, 576 }, { 240, 180 }, { 320, 240 }, {  -1,  -1 }
583 };
584
585 static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
586   int i;
587
588   for (i=0; i < length; i++) {
589     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
590   }
591
592   return value;
593 }
594
595 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
596                                          int width, int height, int value) {
597   int x, y;
598
599   for (y=0; y < height; y++) {
600     for (x=0; x < width; x++) {
601       value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
602     }
603
604     pixels += pitch;
605   }
606
607   return value;
608 }
609
610 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
611   uint8_t seed;
612   int     i;
613
614   out[0] = get_bits (bitbuf, 8);
615
616   seed = string_table[out[0]];
617
618   for (i=1; i <= out[0]; i++) {
619     out[i] = get_bits (bitbuf, 8) ^ seed;
620     seed   = string_table[out[i] ^ seed];
621   }
622 }
623
624 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
625   int frame_size_code;
626   int temporal_reference;
627
628   temporal_reference = get_bits (bitbuf, 8);
629
630   /* frame type */
631   s->pict_type= get_bits (bitbuf, 2)+1;
632   if(s->pict_type==4) 
633       return -1;
634       
635   if (s->pict_type == I_TYPE) {
636
637     /* unknown fields */
638     if (s->f_code == 0x50 || s->f_code == 0x60) {
639       int csum = get_bits (bitbuf, 16);
640
641       csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
642
643 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
644 //              (csum == 0) ? "correct" : "incorrect", csum);
645     }
646
647     if ((s->f_code ^ 0x10) >= 0x50) {
648       char msg[256];
649
650       svq1_parse_string (bitbuf, (char *) msg);
651
652       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
653     }
654
655     skip_bits (bitbuf, 2);
656     skip_bits (bitbuf, 2);
657     skip_bits1 (bitbuf);
658
659     /* load frame size */
660     frame_size_code = get_bits (bitbuf, 3);
661
662     if (frame_size_code == 7) {
663       /* load width, height (12 bits each) */
664       s->width = get_bits (bitbuf, 12);
665       s->height = get_bits (bitbuf, 12);
666
667       if (!s->width || !s->height)
668         return -1;
669     } else {
670       /* get width, height from table */
671       s->width = svq1_frame_size_table[frame_size_code].width;
672       s->height = svq1_frame_size_table[frame_size_code].height;
673     }
674   }
675
676   /* unknown fields */
677   if (get_bits (bitbuf, 1) == 1) {
678     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
679     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
680
681     if (get_bits (bitbuf, 2) != 0)
682       return -1;
683   }
684
685   if (get_bits (bitbuf, 1) == 1) {
686     skip_bits1 (bitbuf);
687     skip_bits (bitbuf, 4);
688     skip_bits1 (bitbuf);
689     skip_bits (bitbuf, 2);
690
691     while (get_bits (bitbuf, 1) == 1) {
692       skip_bits (bitbuf, 8);
693     }
694   }
695   
696   return 0;
697 }
698
699 static int svq1_decode_frame(AVCodecContext *avctx, 
700                              void *data, int *data_size,
701                              uint8_t *buf, int buf_size)
702 {
703   MpegEncContext *s=avctx->priv_data;
704   uint8_t      *current, *previous;
705   int           result, i, x, y, width, height;
706   AVFrame *pict = data; 
707
708   /* initialize bit buffer */
709   init_get_bits(&s->gb,buf,buf_size*8);
710
711   /* decode frame header */
712   s->f_code = get_bits (&s->gb, 22);
713
714   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
715     return -1;
716
717   /* swap some header bytes (why?) */
718   if (s->f_code != 0x20) {
719     uint32_t *src = (uint32_t *) (buf + 4);
720
721     for (i=0; i < 4; i++) {
722       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
723     }
724   }
725
726   result = svq1_decode_frame_header (&s->gb, s);
727
728   if (result != 0)
729   {
730 #ifdef DEBUG_SVQ1
731     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
732 #endif
733     return result;
734   }
735   
736   //FIXME this avoids some confusion for "B frames" without 2 references
737   //this should be removed after libavcodec can handle more flexible picture types & ordering
738   if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
739   
740   if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
741
742   if(MPV_frame_start(s, avctx) < 0)
743       return -1;
744
745   /* decode y, u and v components */
746   for (i=0; i < 3; i++) {
747     int linesize;
748     if (i == 0) {
749       width  = (s->width+15)&~15;
750       height = (s->height+15)&~15;
751       linesize= s->linesize;
752     } else {
753       if(s->flags&CODEC_FLAG_GRAY) break;
754       width  = (s->width/4+15)&~15;
755       height = (s->height/4+15)&~15;
756       linesize= s->uvlinesize;
757     }
758
759     current  = s->current_picture.data[i];
760
761     if(s->pict_type==B_TYPE){
762         previous = s->next_picture.data[i];
763     }else{
764         previous = s->last_picture.data[i];
765     }
766
767     if (s->pict_type == I_TYPE) {
768       /* keyframe */
769       for (y=0; y < height; y+=16) {
770         for (x=0; x < width; x+=16) {
771           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
772           if (result != 0)
773           {
774 //#ifdef DEBUG_SVQ1
775             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
776 //#endif
777             return result;
778           }
779         }
780         current += 16*linesize;
781       }
782     } else {
783       svq1_pmv_t pmv[width/8+3];
784       /* delta frame */
785       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
786
787       for (y=0; y < height; y+=16) {
788         for (x=0; x < width; x+=16) {
789           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
790                                             linesize, pmv, x, y);
791           if (result != 0)
792           {
793 #ifdef DEBUG_SVQ1
794     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
795 #endif
796             return result;
797           }
798         }
799
800         pmv[0].x =
801         pmv[0].y = 0;
802
803         current += 16*linesize;
804       }
805     }
806   }
807   
808   *pict = *(AVFrame*)&s->current_picture;
809
810
811   MPV_frame_end(s);
812   
813   *data_size=sizeof(AVFrame);
814   return buf_size;
815 }
816
817 static int svq1_decode_init(AVCodecContext *avctx)
818 {
819     MpegEncContext *s = avctx->priv_data;
820     int i;
821
822     MPV_decode_defaults(s);
823
824     s->avctx = avctx;
825     s->width = (avctx->width+3)&~3;
826     s->height = (avctx->height+3)&~3;
827     s->codec_id= avctx->codec->id;
828     avctx->pix_fmt = PIX_FMT_YUV410P;
829     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
830     s->flags= avctx->flags;
831     if (MPV_common_init(s) < 0) return -1;
832
833     init_vlc(&svq1_block_type, 2, 4,
834         &svq1_block_type_vlc[0][1], 2, 1,
835         &svq1_block_type_vlc[0][0], 2, 1);
836
837     init_vlc(&svq1_motion_component, 7, 65,
838         &svq1_motion_component_vlc[0][1], 2, 1,
839         &svq1_motion_component_vlc[0][0], 2, 1);
840
841     for (i = 0; i < 6; i++) {
842         init_vlc(&svq1_intra_multistage[i], 3, 8,
843             &svq1_intra_multistage_vlc[i][0][1], 2, 1,
844             &svq1_intra_multistage_vlc[i][0][0], 2, 1);
845         init_vlc(&svq1_inter_multistage[i], 3, 8,
846             &svq1_inter_multistage_vlc[i][0][1], 2, 1,
847             &svq1_inter_multistage_vlc[i][0][0], 2, 1);
848     }
849
850     init_vlc(&svq1_intra_mean, 8, 256,
851         &svq1_intra_mean_vlc[0][1], 4, 2,
852         &svq1_intra_mean_vlc[0][0], 4, 2);
853
854     init_vlc(&svq1_inter_mean, 9, 512,
855         &svq1_inter_mean_vlc[0][1], 4, 2,
856         &svq1_inter_mean_vlc[0][0], 4, 2);
857
858     return 0;
859 }
860
861 static int svq1_decode_end(AVCodecContext *avctx)
862 {
863     MpegEncContext *s = avctx->priv_data;
864
865     MPV_common_end(s);
866     return 0;
867 }
868
869 static void svq1_write_header(SVQ1Context *s, int frame_type)
870 {
871     /* frame code */
872     put_bits(&s->pb, 22, 0x20);
873
874     /* temporal reference (sure hope this is a "don't care") */
875     put_bits(&s->pb, 8, 0x00);
876
877     /* frame type */
878     put_bits(&s->pb, 2, frame_type - 1);
879
880     if (frame_type == I_TYPE) {
881
882         /* no checksum since frame code is 0x20 */
883
884         /* no embedded string either */
885
886         /* output 5 unknown bits (2 + 2 + 1) */
887         put_bits(&s->pb, 5, 0);
888
889         /* forget about matching up resolutions, just use the free-form
890          * resolution code (7) for now */
891         put_bits(&s->pb, 3, 7);
892         put_bits(&s->pb, 12, s->frame_width);
893         put_bits(&s->pb, 12, s->frame_height);
894
895     }
896
897     /* no checksum or extra data (next 2 bits get 0) */
898     put_bits(&s->pb, 2, 0);
899 }
900
901 int level_sizes[6] =      { 8, 16, 32, 64, 128, 256 };
902 int level_log2_sizes[6] = { 3,  4,  5,  6,   7,   8 };
903
904 #define IABS(x) ((x < 0) ? (-(x)) : x)
905
906
907
908 //#define USE_MAD_ALGORITHM
909
910 #ifdef USE_MAD_ALGORITHM
911
912 #define QUALITY_THRESHOLD 100
913 #define THRESHOLD_MULTIPLIER 0.6
914
915 /* This function calculates vector differences using mean absolute 
916  * difference (MAD). */
917
918 static int encode_vector(SVQ1Context *s, unsigned char *vector, 
919     unsigned int level, int threshold)
920 {
921     int i, j, k;
922     int mean;
923     signed short work_vector[256];
924     int best_codebook;
925     int best_score;
926     int multistage_codebooks[6];
927     int number_of_stages = 0;
928     int8_t *current_codebook;
929     int total_deviation;
930     int ret;
931
932 #ifdef DEBUG_SVQ1
933 av_log(s->avctx, AV_LOG_INFO, "  ** recursive entry point: encoding level %d vector at threshold %d\n",
934   level, threshold);
935 #endif
936     if (level > 5) {
937         av_log(s->avctx, AV_LOG_INFO, " help! level %d > 5\n", level);
938         return 0;
939     }
940
941 #ifdef DEBUG_SVQ1
942 for (i = 0; i < level_sizes[level]; i++)
943   av_log(s->avctx, AV_LOG_INFO, " %02X", vector[i]);
944 av_log(s->avctx, AV_LOG_INFO, "\n");
945 #endif
946
947     /* calculate the mean */
948     mean = 0;
949     for (i = 0; i < level_sizes[level]; i++)
950         mean += vector[i];
951     mean >>= level_log2_sizes[level];
952
953 #ifdef DEBUG_SVQ1
954 av_log(s->avctx, AV_LOG_INFO, " vector mean = 0x%02X\n", mean);
955 #endif
956
957     /* remove the mean from the vector */
958     total_deviation = 0;
959     for (i = 0; i < level_sizes[level]; i++) {
960         work_vector[i] = (signed short)vector[i] - mean;
961         total_deviation += IABS(work_vector[i]);
962 #ifdef DEBUG_SVQ1
963 av_log(s->avctx, AV_LOG_INFO, " %d", work_vector[i]);
964 #endif
965     }
966
967 #ifdef DEBUG_SVQ1
968 av_log(s->avctx, AV_LOG_INFO, "\n  total deviation = %d\n", total_deviation);
969 #endif
970
971     if (total_deviation < threshold) {
972
973 #ifdef DEBUG_SVQ1
974     av_log(s->avctx, AV_LOG_INFO, " mean-only encoding found for level %d vector, mean = %d\n",
975       level, mean);
976 #endif
977
978         /* indicate that this is the end of the subdivisions */
979         if (level > 0)
980             put_bits(&s->pb, 1, 0);
981
982         /* index 1 in the table indicates mean-only encoding */
983         put_bits(&s->pb, svq1_intra_multistage_vlc[level][1][1],
984             svq1_intra_multistage_vlc[level][1][0]);
985         put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
986             svq1_intra_mean_vlc[mean][0]);
987
988 #ifdef DEBUG_SVQ1
989 av_log(s->avctx, AV_LOG_INFO, "  mean-only L%d, VLC = (0x%X, %d), mean = %d (0x%X, %d)\n", 
990   level,
991   svq1_intra_multistage_vlc[level][1 + number_of_stages][0],
992   svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
993   mean,
994   svq1_intra_mean_vlc[mean][0],
995   svq1_intra_mean_vlc[mean][1]);
996 #endif
997
998         ret = 0;
999
1000     } else {
1001
1002         if (level <= 3) {
1003
1004 #ifdef DEBUG_SVQ1
1005 av_log(s->avctx, AV_LOG_INFO, " multistage VQ search...\n");
1006 #endif
1007             /* conduct multistage VQ search, for each stage... */
1008             for (i = 0; i < 6; i++) {
1009
1010                 best_codebook = 0;
1011                 best_score = 0x7FFFFFFF;
1012                 /* for each codebook in stage */
1013                 for (j = 0; j < 16; j++) {
1014
1015                     total_deviation = 0;
1016                     current_codebook =
1017                         &svq1_intra_codebooks[level]
1018                         [i * level_sizes[level] * 16 + j * level_sizes[level]];
1019                     /* calculate the total deviation for the vector */
1020                     for (k = 0; k < level_sizes[level]; k++) {
1021                         total_deviation += 
1022                             IABS(work_vector[k] - current_codebook[k]);
1023                     }
1024
1025                     /* lowest score so far? */
1026                     if (total_deviation < best_score) {
1027                         best_score = total_deviation;
1028                         best_codebook = j;
1029                     }
1030 #ifdef DEBUG_SVQ1
1031 av_log(s->avctx, AV_LOG_INFO, "  after %d, %d, best codebook is %d with a score of %d (score was %d)\n",
1032   i, j, best_codebook, best_score, total_deviation);
1033 #endif
1034                 }
1035
1036                 /* apply the winning codebook to the work vector and check if
1037                  * the vector meets the quality threshold */
1038                 total_deviation = 0;
1039                 current_codebook =
1040                     &svq1_intra_codebooks[level]
1041                     [i * level_sizes[level] * 16 + j * level_sizes[level]];
1042                 multistage_codebooks[number_of_stages++] = best_codebook;
1043                 for (j = 0; j < level_sizes[level]; j++) {
1044                     work_vector[j] = work_vector[j] - current_codebook[j];
1045                     total_deviation += IABS(work_vector[j]);
1046                 }
1047
1048                 /* do not go forward with the rest of the search if an acceptable
1049                  * codebook combination has been found */
1050                 if (total_deviation < threshold)
1051                     break;
1052             }
1053         }
1054
1055         if ((total_deviation < threshold) || (level == 0)) {
1056 #ifdef DEBUG_SVQ1
1057       av_log(s->avctx, AV_LOG_INFO, " level %d VQ encoding found using mean %d and codebooks", level, mean);
1058       for (i = 0; i < number_of_stages; i++)
1059         av_log(s->avctx, AV_LOG_INFO, " %d", multistage_codebooks[i]);
1060       av_log(s->avctx, AV_LOG_INFO, "\n");
1061 #endif
1062
1063             /* indicate that this is the end of the subdivisions */
1064             if (level > 0)
1065                 put_bits(&s->pb, 1, 0);
1066
1067             /* output the encoding */
1068             put_bits(&s->pb, 
1069                 svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
1070                 svq1_intra_multistage_vlc[level][1 + number_of_stages][0]);
1071             put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
1072                 svq1_intra_mean_vlc[mean][0]);
1073 #ifdef DEBUG_SVQ1
1074 av_log(s->avctx, AV_LOG_INFO, "  L%d: multistage = %d (0x%X, %d), mean = %d (0x%X, %d), codebooks = ", 
1075   level,
1076   number_of_stages,
1077   svq1_intra_multistage_vlc[level][1 + number_of_stages][0],
1078   svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
1079   mean,
1080   svq1_intra_mean_vlc[mean][0],
1081   svq1_intra_mean_vlc[mean][1]);
1082 #endif
1083
1084             for (i = 0; i < number_of_stages; i++)
1085 {
1086 #ifdef DEBUG_SVQ1
1087 av_log(s->avctx, AV_LOG_INFO, "%d ", multistage_codebooks[i]);
1088 #endif
1089                 put_bits(&s->pb, 4, multistage_codebooks[i]);
1090 }
1091 #ifdef DEBUG_SVQ1
1092 av_log(s->avctx, AV_LOG_INFO, "\n");
1093 #endif
1094
1095             ret = 0;
1096
1097         } else {
1098
1099             /* output a subdivision bit to the encoded stream and signal to 
1100              * the calling function that this vector could not be
1101              * coded at the requested threshold and needs to be subdivided */
1102             put_bits(&s->pb, 1, 1);
1103             ret = 1;
1104         }
1105     }
1106
1107     return ret;
1108 }
1109
1110 #else
1111
1112 #define QUALITY_THRESHOLD 100
1113 #define THRESHOLD_MULTIPLIER 0.6
1114
1115 /* This function calculates vector differences using mean square 
1116  * error (MSE). */
1117
1118 static int encode_vector(SVQ1Context *s, unsigned char *vector, 
1119     unsigned int level, int threshold)
1120 {
1121     int i, j, k;
1122     int mean;
1123     signed short work_vector[256];
1124     int best_codebook;
1125     int best_score;
1126     int multistage_codebooks[6];
1127     int number_of_stages = 0;
1128     int8_t *current_codebook;
1129     int mse;
1130     int diff;
1131     int ret;
1132
1133 #ifdef DEBUG_SVQ1
1134 av_log(s->avctx, AV_LOG_INFO, "  ** recursive entry point: encoding level %d vector at threshold %d\n",
1135   level, threshold);
1136 #endif
1137     if (level > 5) {
1138         av_log(s->avctx, AV_LOG_INFO, " help! level %d > 5\n", level);
1139         return 0;
1140     }
1141
1142 #ifdef DEBUG_SVQ1
1143 for (i = 0; i < level_sizes[level]; i++)
1144   av_log(s->avctx, AV_LOG_INFO, " %02X", vector[i]);
1145 av_log(s->avctx, AV_LOG_INFO, "\n");
1146 #endif
1147
1148     /* calculate the mean */
1149     mean = 0;
1150     for (i = 0; i < level_sizes[level]; i++)
1151         mean += vector[i];
1152     mean >>= level_log2_sizes[level];
1153
1154 #ifdef DEBUG_SVQ1
1155 av_log(s->avctx, AV_LOG_INFO, " vector mean = 0x%02X\n", mean);
1156 #endif
1157
1158     /* remove the mean from the vector and compute the resulting MSE */
1159     mse = 0;
1160     for (i = 0; i < level_sizes[level]; i++) {
1161         work_vector[i] = (signed short)vector[i] - mean;
1162         mse += (work_vector[i] * work_vector[i]);
1163 #ifdef DEBUG_SVQ1
1164 av_log(s->avctx, AV_LOG_INFO, " %d", work_vector[i]);
1165 #endif
1166     }
1167     mse >>= level_log2_sizes[level];
1168
1169 #ifdef DEBUG_SVQ1
1170 av_log(s->avctx, AV_LOG_INFO, "\n  MSE = %d\n", mse);
1171 #endif
1172
1173     if (mse < threshold) {
1174
1175 #ifdef DEBUG_SVQ1
1176     av_log(s->avctx, AV_LOG_INFO, " mean-only encoding found for level %d vector, mean = %d\n",
1177       level, mean);
1178 #endif
1179
1180         /* indicate that this is the end of the subdivisions */
1181         if (level > 0)
1182             put_bits(&s->pb, 1, 0);
1183
1184         /* index 1 in the table indicates mean-only encoding */
1185         put_bits(&s->pb, svq1_intra_multistage_vlc[level][1][1],
1186             svq1_intra_multistage_vlc[level][1][0]);
1187         put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
1188             svq1_intra_mean_vlc[mean][0]);
1189
1190 #ifdef DEBUG_SVQ1
1191 av_log(s->avctx, AV_LOG_INFO, "  mean-only L%d, VLC = (0x%X, %d), mean = %d (0x%X, %d)\n", 
1192   level,
1193   svq1_intra_multistage_vlc[level][1 + number_of_stages][0],
1194   svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
1195   mean,
1196   svq1_intra_mean_vlc[mean][0],
1197   svq1_intra_mean_vlc[mean][1]);
1198 #endif
1199
1200         ret = 0;
1201
1202     } else {
1203
1204         if (level <= 3) {
1205
1206 #ifdef DEBUG_SVQ1
1207 av_log(s->avctx, AV_LOG_INFO, " multistage VQ search...\n");
1208 #endif
1209             /* conduct multistage VQ search, for each stage... */
1210             for (i = 0; i < 6; i++) {
1211
1212                 best_codebook = 0;
1213                 best_score = 0x7FFFFFFF;
1214                 /* for each codebook in stage */
1215                 for (j = 0; j < 16; j++) {
1216
1217                     mse = 0;
1218                     current_codebook =
1219                         &svq1_intra_codebooks[level]
1220                         [i * level_sizes[level] * 16 + j * level_sizes[level]];
1221                     /* calculate the MSE for this vector */
1222                     for (k = 0; k < level_sizes[level]; k++) {
1223                         diff = work_vector[k] - current_codebook[k];
1224                         mse += (diff * diff);
1225                     }
1226                     mse >>= level_log2_sizes[level];
1227
1228                     /* lowest score so far? */
1229                     if (mse < best_score) {
1230                         best_score = mse;
1231                         best_codebook = j;
1232                     }
1233 #ifdef DEBUG_SVQ1
1234 av_log(s->avctx, AV_LOG_INFO, "  after %d, %d, best codebook is %d with a score of %d (score was %d)\n",
1235   i, j, best_codebook, best_score, mse);
1236 #endif
1237                 }
1238
1239                 /* apply the winning codebook to the work vector and check if
1240                  * the vector meets the quality threshold */
1241                 mse = 0;
1242                 current_codebook =
1243                     &svq1_intra_codebooks[level]
1244                     [i * level_sizes[level] * 16 + j * level_sizes[level]];
1245                 multistage_codebooks[number_of_stages++] = best_codebook;
1246                 for (j = 0; j < level_sizes[level]; j++) {
1247                     work_vector[j] = work_vector[j] - current_codebook[j];
1248                     mse += (work_vector[j] * work_vector[j]);
1249                 }
1250                 mse >>= level_log2_sizes[level];
1251
1252                 /* do not go forward with the rest of the search if an acceptable
1253                  * codebook combination has been found */
1254                 if (mse < threshold)
1255                     break;
1256             }
1257         }
1258
1259         if ((mse < threshold) || (level == 0)) {
1260 #ifdef DEBUG_SVQ1
1261       av_log(s->avctx, AV_LOG_INFO, " level %d VQ encoding found using mean %d and codebooks", level, mean);
1262       for (i = 0; i < number_of_stages; i++)
1263         av_log(s->avctx, AV_LOG_INFO, " %d", multistage_codebooks[i]);
1264       av_log(s->avctx, AV_LOG_INFO, "\n");
1265 #endif
1266
1267             /* indicate that this is the end of the subdivisions */
1268             if (level > 0)
1269                 put_bits(&s->pb, 1, 0);
1270
1271             /* output the encoding */
1272             put_bits(&s->pb, 
1273                 svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
1274                 svq1_intra_multistage_vlc[level][1 + number_of_stages][0]);
1275             put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
1276                 svq1_intra_mean_vlc[mean][0]);
1277 #ifdef DEBUG_SVQ1
1278 av_log(s->avctx, AV_LOG_INFO, "  L%d: multistage = %d (0x%X, %d), mean = %d (0x%X, %d), codebooks = ", 
1279   level,
1280   number_of_stages,
1281   svq1_intra_multistage_vlc[level][1 + number_of_stages][0],
1282   svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
1283   mean,
1284   svq1_intra_mean_vlc[mean][0],
1285   svq1_intra_mean_vlc[mean][1]);
1286 #endif
1287
1288             for (i = 0; i < number_of_stages; i++)
1289 {
1290 #ifdef DEBUG_SVQ1
1291 av_log(s->avctx, AV_LOG_INFO, "%d ", multistage_codebooks[i]);
1292 #endif
1293                 put_bits(&s->pb, 4, multistage_codebooks[i]);
1294 }
1295 #ifdef DEBUG_SVQ1
1296 av_log(s->avctx, AV_LOG_INFO, "\n");
1297 #endif
1298
1299             ret = 0;
1300
1301         } else {
1302
1303             /* output a subdivision bit to the encoded stream and signal to 
1304              * the calling function that this vector could not be
1305              * coded at the requested threshold and needs to be subdivided */
1306             put_bits(&s->pb, 1, 1);
1307             ret = 1;
1308         }
1309     }
1310
1311     return ret;
1312 }
1313 #endif
1314
1315 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){
1316     int count, y, x, i, j, split, best_mean, best_score, best_count;
1317     int best_vector[6];
1318     int block_sum[7]= {0, 0, 0, 0, 0, 0};
1319     int w= 2<<((level+2)>>1);
1320     int h= 2<<((level+1)>>1);
1321     int size=w*h;
1322     int16_t block[7][256];
1323     const int8_t *codebook_sum, *codebook;
1324     const uint16_t (*mean_vlc)[2];
1325     const uint8_t (*multistage_vlc)[2];
1326
1327     best_score=0;
1328     //FIXME optimize, this doenst need to be done multiple times
1329     if(intra){
1330         codebook_sum= svq1_intra_codebook_sum[level];
1331         codebook= svq1_intra_codebooks[level];
1332         mean_vlc= svq1_intra_mean_vlc;
1333         multistage_vlc= svq1_intra_multistage_vlc[level];
1334         for(y=0; y<h; y++){
1335             for(x=0; x<w; x++){
1336                 int v= src[x + y*stride];
1337                 block[0][x + w*y]= v;
1338                 best_score += v*v;
1339                 block_sum[0] += v;
1340             }
1341         }
1342     }else{
1343         codebook_sum= svq1_inter_codebook_sum[level];
1344         codebook= svq1_inter_codebooks[level];
1345         mean_vlc= svq1_inter_mean_vlc + 256;
1346         multistage_vlc= svq1_inter_multistage_vlc[level];
1347         for(y=0; y<h; y++){
1348             for(x=0; x<w; x++){
1349                 int v= src[x + y*stride] - ref[x + y*stride];
1350                 block[0][x + w*y]= v;
1351                 best_score += v*v;
1352                 block_sum[0] += v;
1353             }
1354         }
1355     }
1356
1357     best_count=0;
1358     best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
1359     best_mean= (block_sum[0] + (size>>1)) >> (level+3);
1360
1361     if(level<4){
1362         for(count=1; count<7; count++){
1363             int best_vector_score= INT_MAX;
1364             int best_vector_sum=-999, best_vector_mean=-999;
1365             const int stage= count-1;
1366             const int8_t *vector;
1367     
1368             for(i=0; i<16; i++){
1369                 int sum= codebook_sum[stage*16 + i];
1370                 int sqr=0;
1371                 int diff, mean, score;
1372     
1373                 vector = codebook + stage*size*16 + i*size;
1374     
1375                 for(j=0; j<size; j++){
1376                     int v= vector[j];
1377                     sqr += (v - block[stage][j])*(v - block[stage][j]);
1378                 }
1379                 diff= block_sum[stage] - sum;
1380                 mean= (diff + (size>>1)) >> (level+3);
1381                 assert(mean >-300 && mean<300);
1382                 if(intra) mean= clip(mean, 0, 255);
1383                 else      mean= clip(mean, -256, 255);
1384                 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1385                 if(score < best_vector_score){
1386                     best_vector_score= score;
1387                     best_vector[stage]= i;
1388                     best_vector_sum= sum;
1389                     best_vector_mean= mean;
1390                 }
1391             }
1392             assert(best_vector_mean != -999);
1393             vector= codebook + stage*size*16 + best_vector[stage]*size;
1394             for(j=0; j<size; j++){
1395                 block[stage+1][j] = block[stage][j] - vector[j];
1396             }
1397             block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1398             best_vector_score += 
1399                 lambda*(+ 1 + 4*count
1400                         + multistage_vlc[1+count][1]
1401                         + mean_vlc[best_vector_mean][1]);
1402     
1403             if(best_vector_score < best_score){
1404                 best_score= best_vector_score;
1405                 best_count= count;
1406                 best_mean= best_vector_mean;
1407             }
1408         }
1409     }
1410     
1411     split=0;
1412     if(best_score > threshold && level){
1413         int score=0;
1414         int offset= (level&1) ? stride*h/2 : w/2;
1415         PutBitContext backup[6];
1416
1417         for(i=level-1; i>=0; i--){
1418             backup[i]= s->reorder_pb[i];
1419         }
1420         score += encode_block(s, src         , ref         , decoded         , stride, level-1, threshold>>1, lambda, intra);
1421         score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1422         score += lambda;
1423         
1424         if(score < best_score){
1425             best_score= score;
1426             split=1;
1427         }else{
1428             for(i=level-1; i>=0; i--){
1429                 s->reorder_pb[i]= backup[i];
1430             }
1431         }
1432     }
1433     if (level > 0)
1434         put_bits(&s->reorder_pb[level], 1, split);
1435
1436     if(!split){
1437         assert((best_mean >= 0 && best_mean<256) || !intra);
1438         assert(best_mean >= -256 && best_mean<256);
1439         assert(best_count >=0 && best_count<7);
1440         assert(level<4 || best_count==0);
1441             
1442         /* output the encoding */
1443         put_bits(&s->reorder_pb[level], 
1444             multistage_vlc[1 + best_count][1],
1445             multistage_vlc[1 + best_count][0]);
1446         put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1447             mean_vlc[best_mean][0]);
1448
1449         for (i = 0; i < best_count; i++){
1450             assert(best_vector[i]>=0 && best_vector[i]<16);
1451             put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1452         }
1453         
1454         for(y=0; y<h; y++){
1455             for(x=0; x<w; x++){
1456                 decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1457             }
1458         }
1459     }
1460
1461     return best_score;
1462 }
1463
1464 static void svq1_encode_plane(SVQ1Context *s, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1465     int width, int height, int src_stride, int stride)
1466 {
1467     unsigned char buffer0[256];
1468     unsigned char buffer1[256];
1469     int current_buffer;
1470     unsigned char *vector;
1471     unsigned char *subvectors;
1472     int vector_count;
1473     int subvector_count;
1474     int x, y;
1475     int i, j;
1476     int block_width, block_height;
1477     int left_edge;
1478     int level;
1479     int threshold[6];
1480     const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1481
1482 static int frame = 0;
1483
1484 #ifdef DEBUG_SVQ1
1485 av_log(s->avctx, AV_LOG_INFO, "********* frame #%d\n", frame++);
1486 #endif
1487
1488     /* figure out the acceptable level thresholds in advance */
1489     threshold[5] = QUALITY_THRESHOLD;
1490     for (level = 4; level >= 0; level--)
1491         threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1492
1493     block_width = (width + 15) / 16;
1494     block_height = (height + 15) / 16;
1495
1496     for (y = 0; y < block_height; y++) {
1497         uint8_t src[stride*16];
1498         
1499         for(i=0; i<16 && i + 16*y<height; i++){
1500             memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1501             for(x=width; x<16*block_width; x++)
1502                 src[i*stride+x]= src[i*stride+x-1];
1503         }
1504         for(; i<16 && i + 16*y<16*block_height; i++)
1505             memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1506
1507         for (x = 0; x < block_width; x++) {
1508             uint8_t reorder_buffer[2][6][7*32];
1509             int count[2][6];
1510             int offset = y * 16 * stride + x * 16;
1511             uint8_t *decoded= decoded_plane + offset;
1512             uint8_t *ref= ref_plane + offset;
1513             int score[2]={0,0}, best;
1514             uint8_t temp[16*stride];
1515
1516 #ifdef DEBUG_SVQ1
1517 av_log(s->avctx, AV_LOG_INFO, "* level 5 vector @ %d, %d:\n", x * 16, y * 16);
1518 #endif
1519             
1520             for(i=0; i<6; i++){
1521                 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1522             }
1523             if(s->picture.pict_type == P_TYPE){
1524                 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1525                 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1526                 score[0]= vlc[1]*lambda;
1527             }
1528             score[0]+= encode_block(s, src+16*x, ref, temp, stride, 5, 64, lambda, 1);
1529             for(i=0; i<6; i++){
1530                 count[0][i]= put_bits_count(&s->reorder_pb[i]);
1531                 flush_put_bits(&s->reorder_pb[i]);
1532                 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1533             }
1534             if(s->picture.pict_type == P_TYPE){
1535                 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1536                 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1537                 score[1] = vlc[1]*lambda;
1538                 for(i=0; i<2; i++){
1539                     vlc= svq1_motion_component_vlc[32];
1540                     put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1541                     score[1] += vlc[1]*lambda;
1542                 }
1543
1544                 score[1]+= encode_block(s, src+16*x, ref, decoded, stride, 5, 64, lambda, 0);
1545                 best= score[1] <= score[0];
1546                 if(best==1){
1547                     for(i=0; i<6; i++){
1548                         count[1][i]= put_bits_count(&s->reorder_pb[i]);
1549                         flush_put_bits(&s->reorder_pb[i]);
1550                     }
1551                 }
1552             }else
1553                 best= 0;
1554                 
1555             s->rd_total += score[best];
1556
1557             for(i=5; i>=0; i--){
1558                 ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1559             }
1560             if(best==0){
1561                 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1562             }
1563             
1564 #if 0
1565             for (i = 0; i < 256; i += 16) {
1566                 memcpy(&buffer0[i], &plane[left_edge], 16);
1567                 left_edge += stride;
1568             }
1569             current_buffer = 1;  /* this will toggle to 0 immediately */
1570
1571             /* perform a breadth-first tree encoding for each vector level */
1572             subvector_count = 1;  /* one subvector at level 5 */
1573             for (level = 5; level >= 0; level--) {
1574
1575                 vector_count = subvector_count;
1576                 subvector_count = 0;
1577
1578                 if (current_buffer == 0) {
1579                     current_buffer = 1;
1580                     vector = buffer1;
1581                     subvectors = buffer0;
1582                 } else {
1583                     current_buffer = 0;
1584                     vector = buffer0;
1585                     subvectors = buffer1;
1586                 }
1587
1588                 /* iterate through each vector in the list */
1589                 for (i = 0; i < vector_count; i++) {
1590
1591                     if (encode_vector(s, vector, level, threshold[level])) {
1592
1593 #ifdef DEBUG_SVQ1
1594 av_log(s->avctx, AV_LOG_INFO, "  split to level %d\n", level - 1);
1595 #endif
1596                         /* subdivide into 2 subvectors for later processing */
1597                         subvector_count += 2;
1598
1599                         if (level - 1 == 3) {
1600                             /* subdivide 16x8 -> 2 8x8 */
1601                             for (j = 0; j < 8; j++) {
1602                                 /* left half */
1603                                 memcpy(subvectors + j * 8, vector + j * 16, 8);
1604                                 /* right half */
1605                                 memcpy(subvectors + 64 + j * 8,
1606                                     vector + 8 + j * 16, 8);
1607                             }
1608                             subvectors += 128;
1609                         } else if (level - 1 == 1) {
1610                             /* subdivide 8x4 -> 2 4x4 */
1611                             for (j = 0; j < 4; j++) {
1612                                 /* left half */
1613                                 memcpy(subvectors + j * 4, vector + j * 8, 4);
1614                                 /* right half */
1615                                 memcpy(subvectors + 16 + j * 4,
1616                                     vector + 4 + j * 8, 4);
1617                             }
1618                             subvectors += 32;
1619                         } else {
1620                             /* first half */
1621                             memcpy(subvectors, vector, level_sizes[level - 1]);
1622                             subvectors += level_sizes[level - 1];
1623                             /* second half */
1624                             memcpy(subvectors, vector + level_sizes[level - 1], 
1625                                 level_sizes[level - 1]);
1626                             subvectors += level_sizes[level - 1];
1627                         }
1628                     }
1629  
1630                     vector += level_sizes[level];
1631                 }
1632
1633                 /* if there are no more subvectors, break early */
1634                 if (!subvector_count)
1635                     break;
1636             }
1637 #endif
1638         }
1639     }
1640 }
1641
1642 /* output a plane with a constant mean value; good for debugging and for
1643  * greyscale encoding but only valid for intra frames */
1644 static void svq1_output_intra_constant_mean(SVQ1Context *s, int block_width, 
1645     int block_height, unsigned char mean)
1646 {
1647     int i;
1648
1649     /* for each level 5 vector, output the specified mean value */
1650     for (i = 0; i < block_width * block_height; i++) {
1651
1652         /* output a 0 before each vector indicating no subdivision */
1653         put_bits(&s->pb, 1, 0);
1654
1655         /* output a 0 indicating mean-only encoding; use index 1 as that
1656          * maps to code 0 */
1657         put_bits(&s->pb, svq1_intra_multistage_vlc[5][1][1],
1658             svq1_intra_multistage_vlc[5][1][0]);
1659
1660         /* output a constant mean */
1661         put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
1662             svq1_intra_mean_vlc[mean][0]);
1663 #ifdef DEBUG_SVQ1
1664 av_log(s->avctx, AV_LOG_INFO, "  const L5 %d/%d: multistage = 0 (0x%X, %d), mean = %d (0x%X, %d)\n", 
1665   i, block_width * block_height,
1666   svq1_intra_multistage_vlc[5][1][0],
1667   svq1_intra_multistage_vlc[5][1][1],
1668   mean,
1669   svq1_intra_mean_vlc[mean][0],
1670   svq1_intra_mean_vlc[mean][1]);
1671 #endif
1672     }
1673 }
1674
1675 static int svq1_encode_init(AVCodecContext *avctx)
1676 {
1677     SVQ1Context * const s = avctx->priv_data;
1678     int i;
1679     unsigned char least_bits_value = 0;
1680     int least_bits;
1681
1682     dsputil_init(&s->dsp, avctx);
1683     avctx->coded_frame= (AVFrame*)&s->picture;
1684
1685     s->frame_width = avctx->width;
1686     s->frame_height = avctx->height;
1687
1688     s->y_block_width = (s->frame_width + 15) / 16;
1689     s->y_block_height = (s->frame_height + 15) / 16;
1690
1691     s->c_block_width = (s->frame_width / 4 + 15) / 16;
1692     s->c_block_height = (s->frame_height / 4 + 15) / 16;
1693
1694 av_log(s->avctx, AV_LOG_INFO, " Hey: %d x %d, %d x %d, %d x %d\n",
1695   s->frame_width, s->frame_height,
1696   s->y_block_width, s->y_block_height,
1697   s->c_block_width, s->c_block_height);
1698
1699     /* allocate a plane for the U & V planes (color, or C, planes) and
1700      * initialize them to the value that is represented by the fewest bits
1701      * in the mean table; the reasoning behind this is that when the border
1702      * vectors are operated upon and possibly subdivided, the mean will be
1703      * removed resulting in a perfect deviation score of 0 and encoded with
1704      * the minimal possible bits */
1705     s->c_plane = av_malloc(s->c_block_width * s->c_block_height * 16 * 16);
1706     least_bits = 10000;
1707     for (i = 0; i < 256; i++)
1708         if (svq1_intra_mean_vlc[i][1] < least_bits) {
1709             least_bits = svq1_intra_mean_vlc[i][1];
1710             least_bits_value = i;
1711         }
1712     memset(s->c_plane, least_bits_value, 
1713         s->c_block_width * s->c_block_height * 16 * 16);
1714
1715     return 0;
1716 }
1717
1718 static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf, 
1719     int buf_size, void *data)
1720 {
1721     SVQ1Context * const s = avctx->priv_data;
1722     AVFrame *pict = data;
1723     AVFrame * const p= (AVFrame*)&s->picture;
1724     AVFrame temp;
1725     int i;
1726
1727     if(avctx->pix_fmt != PIX_FMT_YUV410P){
1728         av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1729         return -1;
1730     }
1731     
1732     if(!s->current_picture.data[0]){
1733         avctx->get_buffer(avctx, &s->current_picture);
1734         avctx->get_buffer(avctx, &s->last_picture);
1735     }
1736     
1737     temp= s->current_picture;
1738     s->current_picture= s->last_picture;
1739     s->last_picture= temp;
1740     
1741     init_put_bits(&s->pb, buf, buf_size);
1742
1743     *p = *pict;
1744     p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1745     p->key_frame = p->pict_type == I_TYPE;
1746
1747     svq1_write_header(s, p->pict_type);
1748     for(i=0; i<3; i++){
1749         svq1_encode_plane(s, 
1750             s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1751             s->frame_width / (i?4:1), s->frame_height / (i?4:1), 
1752             s->picture.linesize[i], s->current_picture.linesize[i]);
1753     }
1754
1755 //    align_put_bits(&s->pb);
1756     while(put_bits_count(&s->pb) & 31)
1757         put_bits(&s->pb, 1, 0);
1758         
1759     flush_put_bits(&s->pb);
1760
1761     return (put_bits_count(&s->pb) / 8);
1762 }
1763
1764 static int svq1_encode_end(AVCodecContext *avctx)
1765 {
1766     SVQ1Context * const s = avctx->priv_data;
1767
1768     av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1769     
1770     av_free(s->c_plane);
1771
1772     return 0;
1773 }
1774
1775 AVCodec svq1_decoder = {
1776     "svq1",
1777     CODEC_TYPE_VIDEO,
1778     CODEC_ID_SVQ1,
1779     sizeof(MpegEncContext),
1780     svq1_decode_init,
1781     NULL,
1782     svq1_decode_end,
1783     svq1_decode_frame,
1784     CODEC_CAP_DR1,
1785     .flush= ff_mpeg_flush,
1786 };
1787
1788 #ifdef CONFIG_ENCODERS
1789
1790 AVCodec svq1_encoder = {
1791     "svq1",
1792     CODEC_TYPE_VIDEO,
1793     CODEC_ID_SVQ1,
1794     sizeof(SVQ1Context),
1795     svq1_encode_init,
1796     svq1_encode_frame,
1797     svq1_encode_end,
1798 };
1799
1800 #endif //CONFIG_ENCODERS