3 * Copyright (C) 2002 the xine project
4 * Copyright (C) 2002 the ffmpeg project
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.
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.
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
22 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
24 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
29 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
30 * For more information of the SVQ1 algorithm, visit:
31 * http://www.pcisys.net/~melanson/codecs/
45 #include "mpegvideo.h"
51 extern const uint8_t mvtab[33][2];
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;
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
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;
70 AVFrame current_picture;
75 PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
80 /* Y plane block dimensions */
84 /* U & V plane (C planes) block dimensions */
90 int16_t (*motion_val8[3])[2];
91 int16_t (*motion_val16[3])[2];
96 /* motion vector (prediction) */
97 typedef struct svq1_pmv_s {
103 #include "svq1_vlc.h"
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
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
175 #define SVQ1_PROCESS_VECTOR()\
176 for (; level > 0; i++) {\
177 /* process next depth */\
183 /* divide block if next bit set */\
184 if (get_bits (bitbuf, 1) == 0)\
186 /* add child nodes */\
187 list[n++] = list[i];\
188 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
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);\
199 /* clip to [0..255] */\
200 if (n1 & 0xFF00FF00) {\
201 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
203 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
204 n1 &= (n3 & 0x00FF00FF);\
207 if (n2 & 0xFF00FF00) {\
208 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
210 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
211 n2 &= (n3 & 0x00FF00FF);\
214 #define SVQ1_DO_CODEBOOK_INTRA()\
215 for (y=0; y < height; y++) {\
216 for (x=0; x < (width / 4); x++, codebook++) {\
221 dst[x] = (n1 << 8) | n2;\
226 #define SVQ1_DO_CODEBOOK_NONINTRA()\
227 for (y=0; y < height; y++) {\
228 for (x=0; x < (width / 4); x++, codebook++) {\
230 /* add mean value to vector */\
231 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
232 n2 = (n3 & 0x00FF00FF) + n4;\
235 dst[x] = (n1 << 8) | n2;\
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);\
247 mean -= (stages * 128);\
248 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
250 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
254 const uint32_t *codebook;
258 unsigned x, y, width, height, level;
259 uint32_t n1, n2, n3, n4;
261 /* initialize list for breadth first processing of vectors */
264 /* recursively process vector */
265 for (i=0, m=1, n=1, level=5; i < n; i++) {
266 SVQ1_PROCESS_VECTOR();
268 /* destination address and vector size */
269 dst = (uint32_t *) list[i];
270 width = 1 << ((4 + level) /2);
271 height = 1 << ((3 + level) /2);
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;
277 for (y=0; y < height; y++) {
278 memset (&dst[y*(pitch / 4)], 0, width);
280 continue; /* skip vector */
283 if ((stages > 0) && (level >= 4)) {
285 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
287 return -1; /* invalid vector */
290 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
293 for (y=0; y < height; y++) {
294 memset (&dst[y*(pitch / 4)], mean, width);
297 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
298 SVQ1_DO_CODEBOOK_INTRA()
305 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
309 const uint32_t *codebook;
313 int x, y, width, height, level;
314 uint32_t n1, n2, n3, n4;
316 /* initialize list for breadth first processing of vectors */
319 /* recursively process vector */
320 for (i=0, m=1, n=1, level=5; i < n; i++) {
321 SVQ1_PROCESS_VECTOR();
323 /* destination address and vector size */
324 dst = (uint32_t *) list[i];
325 width = 1 << ((4 + level) /2);
326 height = 1 << ((3 + level) /2);
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;
331 if (stages == -1) continue; /* skip vector */
333 if ((stages > 0) && (level >= 4)) {
335 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
337 return -1; /* invalid vector */
340 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
342 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
343 SVQ1_DO_CODEBOOK_NONINTRA()
348 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
352 for (i=0; i < 2; i++) {
354 /* get motion code */
355 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
359 if(get_bits1(bitbuf)) diff= -diff;
362 /* add median of motion vector predictors and clip result */
364 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
366 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
372 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
377 src = &previous[x + y*pitch];
380 for (i=0; i < 16; i++) {
381 memcpy (dst, src, 16);
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) {
396 /* predict and decode motion vector */
403 pmv[1] = &motion[(x / 8) + 2];
404 pmv[2] = &motion[(x / 8) + 4];
407 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
413 motion[(x / 8) + 2].x =
414 motion[(x / 8) + 3].x = mv.x;
416 motion[(x / 8) + 2].y =
417 motion[(x / 8) + 3].y = mv.y;
419 if(y + (mv.y >> 1)<0)
421 if(x + (mv.x >> 1)<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));
431 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
434 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
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) {
448 /* predict and decode motion vector (0) */
455 pmv[1] = &motion[(x / 8) + 2];
456 pmv[2] = &motion[(x / 8) + 4];
459 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
464 /* predict and decode motion vector (1) */
471 pmv[1] = &motion[(x / 8) + 3];
473 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
478 /* predict and decode motion vector (2) */
480 pmv[2] = &motion[(x / 8) + 1];
482 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
487 /* predict and decode motion vector (3) */
488 pmv[2] = &motion[(x / 8) + 2];
489 pmv[3] = &motion[(x / 8) + 3];
491 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
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;
501 ///XXX /FIXME cliping or padding?
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));
513 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
516 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
518 /* select next block */
520 current += 8*(pitch - 1);
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) {
536 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
538 /* reset motion vectors */
539 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
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;
548 switch (block_type) {
549 case SVQ1_BLOCK_SKIP:
550 svq1_skip_block (current, previous, pitch, x, y);
553 case SVQ1_BLOCK_INTER:
554 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
559 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
563 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
566 case SVQ1_BLOCK_INTER_4V:
567 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
572 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
576 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
579 case SVQ1_BLOCK_INTRA:
580 result = svq1_decode_block_intra (bitbuf, current, pitch);
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 }
593 static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
596 for (i=0; i < length; i++) {
597 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
603 #if 0 /* unused, remove? */
604 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
605 int width, int height, int value) {
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);
620 #ifdef CONFIG_DECODERS
621 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
625 out[0] = get_bits (bitbuf, 8);
627 seed = string_table[out[0]];
629 for (i=1; i <= out[0]; i++) {
630 out[i] = get_bits (bitbuf, 8) ^ seed;
631 seed = string_table[out[i] ^ seed];
635 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
637 int temporal_reference;
639 temporal_reference = get_bits (bitbuf, 8);
642 s->pict_type= get_bits (bitbuf, 2)+1;
646 if (s->pict_type == I_TYPE) {
649 if (s->f_code == 0x50 || s->f_code == 0x60) {
650 int csum = get_bits (bitbuf, 16);
652 csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
654 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
655 // (csum == 0) ? "correct" : "incorrect", csum);
658 if ((s->f_code ^ 0x10) >= 0x50) {
661 svq1_parse_string (bitbuf, msg);
663 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
666 skip_bits (bitbuf, 2);
667 skip_bits (bitbuf, 2);
670 /* load frame size */
671 frame_size_code = get_bits (bitbuf, 3);
673 if (frame_size_code == 7) {
674 /* load width, height (12 bits each) */
675 s->width = get_bits (bitbuf, 12);
676 s->height = get_bits (bitbuf, 12);
678 if (!s->width || !s->height)
681 /* get width, height from table */
682 s->width = svq1_frame_size_table[frame_size_code].width;
683 s->height = svq1_frame_size_table[frame_size_code].height;
688 if (get_bits (bitbuf, 1) == 1) {
689 skip_bits1 (bitbuf); /* use packet checksum if (1) */
690 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
692 if (get_bits (bitbuf, 2) != 0)
696 if (get_bits (bitbuf, 1) == 1) {
698 skip_bits (bitbuf, 4);
700 skip_bits (bitbuf, 2);
702 while (get_bits (bitbuf, 1) == 1) {
703 skip_bits (bitbuf, 8);
710 static int svq1_decode_frame(AVCodecContext *avctx,
711 void *data, int *data_size,
712 uint8_t *buf, int buf_size)
714 MpegEncContext *s=avctx->priv_data;
715 uint8_t *current, *previous;
716 int result, i, x, y, width, height;
717 AVFrame *pict = data;
719 /* initialize bit buffer */
720 init_get_bits(&s->gb,buf,buf_size*8);
722 /* decode frame header */
723 s->f_code = get_bits (&s->gb, 22);
725 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
728 /* swap some header bytes (why?) */
729 if (s->f_code != 0x20) {
730 uint32_t *src = (uint32_t *) (buf + 4);
732 for (i=0; i < 4; i++) {
733 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
737 result = svq1_decode_frame_header (&s->gb, s);
742 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
747 //FIXME this avoids some confusion for "B frames" without 2 references
748 //this should be removed after libavcodec can handle more flexible picture types & ordering
749 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
751 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
752 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
753 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
754 || avctx->skip_frame >= AVDISCARD_ALL)
757 if(MPV_frame_start(s, avctx) < 0)
760 /* decode y, u and v components */
761 for (i=0; i < 3; i++) {
764 width = (s->width+15)&~15;
765 height = (s->height+15)&~15;
766 linesize= s->linesize;
768 if(s->flags&CODEC_FLAG_GRAY) break;
769 width = (s->width/4+15)&~15;
770 height = (s->height/4+15)&~15;
771 linesize= s->uvlinesize;
774 current = s->current_picture.data[i];
776 if(s->pict_type==B_TYPE){
777 previous = s->next_picture.data[i];
779 previous = s->last_picture.data[i];
782 if (s->pict_type == I_TYPE) {
784 for (y=0; y < height; y+=16) {
785 for (x=0; x < width; x+=16) {
786 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
790 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
795 current += 16*linesize;
798 svq1_pmv_t pmv[width/8+3];
800 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
802 for (y=0; y < height; y+=16) {
803 for (x=0; x < width; x+=16) {
804 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
805 linesize, pmv, x, y);
809 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
818 current += 16*linesize;
823 *pict = *(AVFrame*)&s->current_picture;
828 *data_size=sizeof(AVFrame);
832 static int svq1_decode_init(AVCodecContext *avctx)
834 MpegEncContext *s = avctx->priv_data;
837 MPV_decode_defaults(s);
840 s->width = (avctx->width+3)&~3;
841 s->height = (avctx->height+3)&~3;
842 s->codec_id= avctx->codec->id;
843 avctx->pix_fmt = PIX_FMT_YUV410P;
844 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
845 s->flags= avctx->flags;
846 if (MPV_common_init(s) < 0) return -1;
848 init_vlc(&svq1_block_type, 2, 4,
849 &svq1_block_type_vlc[0][1], 2, 1,
850 &svq1_block_type_vlc[0][0], 2, 1, 1);
852 init_vlc(&svq1_motion_component, 7, 33,
854 &mvtab[0][0], 2, 1, 1);
856 for (i = 0; i < 6; i++) {
857 init_vlc(&svq1_intra_multistage[i], 3, 8,
858 &svq1_intra_multistage_vlc[i][0][1], 2, 1,
859 &svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
860 init_vlc(&svq1_inter_multistage[i], 3, 8,
861 &svq1_inter_multistage_vlc[i][0][1], 2, 1,
862 &svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
865 init_vlc(&svq1_intra_mean, 8, 256,
866 &svq1_intra_mean_vlc[0][1], 4, 2,
867 &svq1_intra_mean_vlc[0][0], 4, 2, 1);
869 init_vlc(&svq1_inter_mean, 9, 512,
870 &svq1_inter_mean_vlc[0][1], 4, 2,
871 &svq1_inter_mean_vlc[0][0], 4, 2, 1);
876 static int svq1_decode_end(AVCodecContext *avctx)
878 MpegEncContext *s = avctx->priv_data;
883 #endif /* CONFIG_DECODERS */
885 #ifdef CONFIG_ENCODERS
886 static void svq1_write_header(SVQ1Context *s, int frame_type)
891 put_bits(&s->pb, 22, 0x20);
893 /* temporal reference (sure hope this is a "don't care") */
894 put_bits(&s->pb, 8, 0x00);
897 put_bits(&s->pb, 2, frame_type - 1);
899 if (frame_type == I_TYPE) {
901 /* no checksum since frame code is 0x20 */
903 /* no embedded string either */
905 /* output 5 unknown bits (2 + 2 + 1) */
906 put_bits(&s->pb, 5, 0);
908 for (i = 0; i < 7; i++)
910 if ((svq1_frame_size_table[i].width == s->frame_width) &&
911 (svq1_frame_size_table[i].height == s->frame_height))
913 put_bits(&s->pb, 3, i);
920 put_bits(&s->pb, 3, 7);
921 put_bits(&s->pb, 12, s->frame_width);
922 put_bits(&s->pb, 12, s->frame_height);
926 /* no checksum or extra data (next 2 bits get 0) */
927 put_bits(&s->pb, 2, 0);
931 #define QUALITY_THRESHOLD 100
932 #define THRESHOLD_MULTIPLIER 0.6
934 #if defined(HAVE_ALTIVEC)
938 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){
939 int count, y, x, i, j, split, best_mean, best_score, best_count;
941 int block_sum[7]= {0, 0, 0, 0, 0, 0};
942 int w= 2<<((level+2)>>1);
943 int h= 2<<((level+1)>>1);
945 int16_t block[7][256];
946 const int8_t *codebook_sum, *codebook;
947 const uint16_t (*mean_vlc)[2];
948 const uint8_t (*multistage_vlc)[2];
951 //FIXME optimize, this doenst need to be done multiple times
953 codebook_sum= svq1_intra_codebook_sum[level];
954 codebook= svq1_intra_codebooks[level];
955 mean_vlc= svq1_intra_mean_vlc;
956 multistage_vlc= svq1_intra_multistage_vlc[level];
959 int v= src[x + y*stride];
960 block[0][x + w*y]= v;
966 codebook_sum= svq1_inter_codebook_sum[level];
967 codebook= svq1_inter_codebooks[level];
968 mean_vlc= svq1_inter_mean_vlc + 256;
969 multistage_vlc= svq1_inter_multistage_vlc[level];
972 int v= src[x + y*stride] - ref[x + y*stride];
973 block[0][x + w*y]= v;
981 best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
982 best_mean= (block_sum[0] + (size>>1)) >> (level+3);
985 for(count=1; count<7; count++){
986 int best_vector_score= INT_MAX;
987 int best_vector_sum=-999, best_vector_mean=-999;
988 const int stage= count-1;
989 const int8_t *vector;
992 int sum= codebook_sum[stage*16 + i];
994 int diff, mean, score;
996 vector = codebook + stage*size*16 + i*size;
998 for(j=0; j<size; j++){
1000 sqr += (v - block[stage][j])*(v - block[stage][j]);
1002 diff= block_sum[stage] - sum;
1003 mean= (diff + (size>>1)) >> (level+3);
1004 assert(mean >-300 && mean<300);
1005 if(intra) mean= clip(mean, 0, 255);
1006 else mean= clip(mean, -256, 255);
1007 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1008 if(score < best_vector_score){
1009 best_vector_score= score;
1010 best_vector[stage]= i;
1011 best_vector_sum= sum;
1012 best_vector_mean= mean;
1015 assert(best_vector_mean != -999);
1016 vector= codebook + stage*size*16 + best_vector[stage]*size;
1017 for(j=0; j<size; j++){
1018 block[stage+1][j] = block[stage][j] - vector[j];
1020 block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1021 best_vector_score +=
1022 lambda*(+ 1 + 4*count
1023 + multistage_vlc[1+count][1]
1024 + mean_vlc[best_vector_mean][1]);
1026 if(best_vector_score < best_score){
1027 best_score= best_vector_score;
1029 best_mean= best_vector_mean;
1035 if(best_score > threshold && level){
1037 int offset= (level&1) ? stride*h/2 : w/2;
1038 PutBitContext backup[6];
1040 for(i=level-1; i>=0; i--){
1041 backup[i]= s->reorder_pb[i];
1043 score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
1044 score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1047 if(score < best_score){
1051 for(i=level-1; i>=0; i--){
1052 s->reorder_pb[i]= backup[i];
1057 put_bits(&s->reorder_pb[level], 1, split);
1060 assert((best_mean >= 0 && best_mean<256) || !intra);
1061 assert(best_mean >= -256 && best_mean<256);
1062 assert(best_count >=0 && best_count<7);
1063 assert(level<4 || best_count==0);
1065 /* output the encoding */
1066 put_bits(&s->reorder_pb[level],
1067 multistage_vlc[1 + best_count][1],
1068 multistage_vlc[1 + best_count][0]);
1069 put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1070 mean_vlc[best_mean][0]);
1072 for (i = 0; i < best_count; i++){
1073 assert(best_vector[i]>=0 && best_vector[i]<16);
1074 put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1079 decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1088 static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1089 int width, int height, int src_stride, int stride)
1093 int block_width, block_height;
1096 const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1098 /* figure out the acceptable level thresholds in advance */
1099 threshold[5] = QUALITY_THRESHOLD;
1100 for (level = 4; level >= 0; level--)
1101 threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1103 block_width = (width + 15) / 16;
1104 block_height = (height + 15) / 16;
1106 if(s->picture.pict_type == P_TYPE){
1107 s->m.avctx= s->avctx;
1108 s->m.current_picture_ptr= &s->m.current_picture;
1109 s->m.last_picture_ptr = &s->m.last_picture;
1110 s->m.last_picture.data[0]= ref_plane;
1112 s->m.last_picture.linesize[0]=
1113 s->m.new_picture.linesize[0]=
1114 s->m.current_picture.linesize[0]= stride;
1116 s->m.height= height;
1117 s->m.mb_width= block_width;
1118 s->m.mb_height= block_height;
1119 s->m.mb_stride= s->m.mb_width+1;
1120 s->m.b8_stride= 2*s->m.mb_width+1;
1122 s->m.pict_type= s->picture.pict_type;
1123 s->m.me_method= s->avctx->me_method;
1124 s->m.me.scene_change_score=0;
1125 s->m.flags= s->avctx->flags;
1126 // s->m.out_format = FMT_H263;
1127 // s->m.unrestricted_mv= 1;
1129 s->m.lambda= s->picture.quality;
1130 s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1131 s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1133 if(!s->motion_val8[plane]){
1134 s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1135 s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1138 s->m.mb_type= s->mb_type;
1140 //dummies, to avoid segfaults
1141 s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
1142 s->m.current_picture.mb_var= (uint16_t*)s->dummy;
1143 s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1144 s->m.current_picture.mb_type= s->dummy;
1146 s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1147 s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1148 s->m.dsp= s->dsp; //move
1151 s->m.me.dia_size= s->avctx->dia_size;
1152 s->m.first_slice_line=1;
1153 for (y = 0; y < block_height; y++) {
1154 uint8_t src[stride*16];
1156 s->m.new_picture.data[0]= src - y*16*stride; //ugly
1159 for(i=0; i<16 && i + 16*y<height; i++){
1160 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1161 for(x=width; x<16*block_width; x++)
1162 src[i*stride+x]= src[i*stride+x-1];
1164 for(; i<16 && i + 16*y<16*block_height; i++)
1165 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1167 for (x = 0; x < block_width; x++) {
1169 ff_init_block_index(&s->m);
1170 ff_update_block_index(&s->m);
1172 ff_estimate_p_frame_motion(&s->m, x, y);
1174 s->m.first_slice_line=0;
1177 ff_fix_long_p_mvs(&s->m);
1178 ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1181 s->m.first_slice_line=1;
1182 for (y = 0; y < block_height; y++) {
1183 uint8_t src[stride*16];
1185 for(i=0; i<16 && i + 16*y<height; i++){
1186 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1187 for(x=width; x<16*block_width; x++)
1188 src[i*stride+x]= src[i*stride+x-1];
1190 for(; i<16 && i + 16*y<16*block_height; i++)
1191 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1194 for (x = 0; x < block_width; x++) {
1195 uint8_t reorder_buffer[3][6][7*32];
1197 int offset = y * 16 * stride + x * 16;
1198 uint8_t *decoded= decoded_plane + offset;
1199 uint8_t *ref= ref_plane + offset;
1200 int score[4]={0,0,0,0}, best;
1201 uint8_t temp[16*stride];
1203 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
1204 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1209 ff_init_block_index(&s->m);
1210 ff_update_block_index(&s->m);
1212 if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1214 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1216 if(s->picture.pict_type == P_TYPE){
1217 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1218 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1219 score[0]= vlc[1]*lambda;
1221 score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1223 count[0][i]= put_bits_count(&s->reorder_pb[i]);
1224 flush_put_bits(&s->reorder_pb[i]);
1231 if(s->picture.pict_type == P_TYPE){
1232 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1233 int mx, my, pred_x, pred_y, dxy;
1234 int16_t *motion_ptr;
1236 motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1237 if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1239 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1241 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1243 s->m.pb= s->reorder_pb[5];
1246 assert(mx>=-32 && mx<=31);
1247 assert(my>=-32 && my<=31);
1248 assert(pred_x>=-32 && pred_x<=31);
1249 assert(pred_y>=-32 && pred_y<=31);
1250 ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1251 ff_h263_encode_motion(&s->m, my - pred_y, 1);
1252 s->reorder_pb[5]= s->m.pb;
1253 score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1255 dxy= (mx&1) + 2*(my&1);
1257 s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1259 score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1260 best= score[1] <= score[0];
1262 vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1263 score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1264 score[2]+= vlc[1]*lambda;
1265 if(score[2] < score[best] && mx==0 && my==0){
1267 s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1271 put_bits(&s->pb, vlc[1], vlc[0]);
1277 count[1][i]= put_bits_count(&s->reorder_pb[i]);
1278 flush_put_bits(&s->reorder_pb[i]);
1281 motion_ptr[0 ] = motion_ptr[1 ]=
1282 motion_ptr[2 ] = motion_ptr[3 ]=
1283 motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1284 motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1288 s->rd_total += score[best];
1290 for(i=5; i>=0; i--){
1291 ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1294 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1297 s->m.first_slice_line=0;
1302 static int svq1_encode_init(AVCodecContext *avctx)
1304 SVQ1Context * const s = avctx->priv_data;
1306 dsputil_init(&s->dsp, avctx);
1307 avctx->coded_frame= (AVFrame*)&s->picture;
1309 s->frame_width = avctx->width;
1310 s->frame_height = avctx->height;
1312 s->y_block_width = (s->frame_width + 15) / 16;
1313 s->y_block_height = (s->frame_height + 15) / 16;
1315 s->c_block_width = (s->frame_width / 4 + 15) / 16;
1316 s->c_block_height = (s->frame_height / 4 + 15) / 16;
1320 s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
1321 s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1322 s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1323 s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1324 s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1325 h263_encode_init(&s->m); //mv_penalty
1330 static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
1331 int buf_size, void *data)
1333 SVQ1Context * const s = avctx->priv_data;
1334 AVFrame *pict = data;
1335 AVFrame * const p= (AVFrame*)&s->picture;
1339 if(avctx->pix_fmt != PIX_FMT_YUV410P){
1340 av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1344 if(!s->current_picture.data[0]){
1345 avctx->get_buffer(avctx, &s->current_picture);
1346 avctx->get_buffer(avctx, &s->last_picture);
1349 temp= s->current_picture;
1350 s->current_picture= s->last_picture;
1351 s->last_picture= temp;
1353 init_put_bits(&s->pb, buf, buf_size);
1356 p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1357 p->key_frame = p->pict_type == I_TYPE;
1359 svq1_write_header(s, p->pict_type);
1361 if(svq1_encode_plane(s, i,
1362 s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1363 s->frame_width / (i?4:1), s->frame_height / (i?4:1),
1364 s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
1368 // align_put_bits(&s->pb);
1369 while(put_bits_count(&s->pb) & 31)
1370 put_bits(&s->pb, 1, 0);
1372 flush_put_bits(&s->pb);
1374 return (put_bits_count(&s->pb) / 8);
1377 static int svq1_encode_end(AVCodecContext *avctx)
1379 SVQ1Context * const s = avctx->priv_data;
1382 av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1384 av_freep(&s->m.me.scratchpad);
1385 av_freep(&s->m.me.map);
1386 av_freep(&s->m.me.score_map);
1387 av_freep(&s->mb_type);
1388 av_freep(&s->dummy);
1391 av_freep(&s->motion_val8[i]);
1392 av_freep(&s->motion_val16[i]);
1398 #endif //CONFIG_ENCODERS
1400 #ifdef CONFIG_DECODERS
1401 AVCodec svq1_decoder = {
1405 sizeof(MpegEncContext),
1411 .flush= ff_mpeg_flush,
1412 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1416 #ifdef CONFIG_ENCODERS
1418 AVCodec svq1_encoder = {
1422 sizeof(SVQ1Context),
1426 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1429 #endif //CONFIG_ENCODERS