3 * Copyright (C) 2002 the xine project
4 * Copyright (C) 2002 the ffmpeg project
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
24 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
26 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
31 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
32 * For more information of the SVQ1 algorithm, visit:
33 * http://www.pcisys.net/~melanson/codecs/
47 #include "mpegvideo.h"
53 extern const uint8_t mvtab[33][2];
55 static VLC svq1_block_type;
56 static VLC svq1_motion_component;
57 static VLC svq1_intra_multistage[6];
58 static VLC svq1_inter_multistage[6];
59 static VLC svq1_intra_mean;
60 static VLC svq1_inter_mean;
62 #define SVQ1_BLOCK_SKIP 0
63 #define SVQ1_BLOCK_INTER 1
64 #define SVQ1_BLOCK_INTER_4V 2
65 #define SVQ1_BLOCK_INTRA 3
67 typedef struct SVQ1Context {
68 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)
69 AVCodecContext *avctx;
72 AVFrame current_picture;
77 PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
82 /* Y plane block dimensions */
86 /* U & V plane (C planes) block dimensions */
92 int16_t (*motion_val8[3])[2];
93 int16_t (*motion_val16[3])[2];
98 /* motion vector (prediction) */
99 typedef struct svq1_pmv_s {
105 #include "svq1_vlc.h"
107 static const uint16_t checksum_table[256] = {
108 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
109 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
110 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
111 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
112 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
113 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
114 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
115 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
116 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
117 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
118 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
119 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
120 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
121 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
122 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
123 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
124 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
125 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
126 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
127 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
128 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
129 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
130 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
131 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
132 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
133 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
134 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
135 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
136 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
137 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
138 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
139 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
142 static const uint8_t string_table[256] = {
143 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
144 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
145 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
146 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
147 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
148 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
149 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
150 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
151 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
152 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
153 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
154 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
155 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
156 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
157 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
158 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
159 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
160 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
161 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
162 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
163 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
164 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
165 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
166 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
167 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
168 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
169 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
170 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
171 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
172 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
173 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
174 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
177 #define SVQ1_PROCESS_VECTOR()\
178 for (; level > 0; i++) {\
179 /* process next depth */\
185 /* divide block if next bit set */\
186 if (get_bits (bitbuf, 1) == 0)\
188 /* add child nodes */\
189 list[n++] = list[i];\
190 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
193 #define SVQ1_ADD_CODEBOOK()\
194 /* add codebook entries to vector */\
195 for (j=0; j < stages; j++) {\
196 n3 = codebook[entries[j]] ^ 0x80808080;\
197 n1 += ((n3 & 0xFF00FF00) >> 8);\
198 n2 += (n3 & 0x00FF00FF);\
201 /* clip to [0..255] */\
202 if (n1 & 0xFF00FF00) {\
203 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
205 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
206 n1 &= (n3 & 0x00FF00FF);\
209 if (n2 & 0xFF00FF00) {\
210 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
212 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
213 n2 &= (n3 & 0x00FF00FF);\
216 #define SVQ1_DO_CODEBOOK_INTRA()\
217 for (y=0; y < height; y++) {\
218 for (x=0; x < (width / 4); x++, codebook++) {\
223 dst[x] = (n1 << 8) | n2;\
228 #define SVQ1_DO_CODEBOOK_NONINTRA()\
229 for (y=0; y < height; y++) {\
230 for (x=0; x < (width / 4); x++, codebook++) {\
232 /* add mean value to vector */\
233 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
234 n2 = (n3 & 0x00FF00FF) + n4;\
237 dst[x] = (n1 << 8) | n2;\
242 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
243 codebook = (const uint32_t *) cbook[level];\
244 bit_cache = get_bits (bitbuf, 4*stages);\
245 /* calculate codebook entries for this vector */\
246 for (j=0; j < stages; j++) {\
247 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
249 mean -= (stages * 128);\
250 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
252 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
256 const uint32_t *codebook;
260 unsigned x, y, width, height, level;
261 uint32_t n1, n2, n3, n4;
263 /* initialize list for breadth first processing of vectors */
266 /* recursively process vector */
267 for (i=0, m=1, n=1, level=5; i < n; i++) {
268 SVQ1_PROCESS_VECTOR();
270 /* destination address and vector size */
271 dst = (uint32_t *) list[i];
272 width = 1 << ((4 + level) /2);
273 height = 1 << ((3 + level) /2);
275 /* get number of stages (-1 skips vector, 0 for mean only) */
276 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
279 for (y=0; y < height; y++) {
280 memset (&dst[y*(pitch / 4)], 0, width);
282 continue; /* skip vector */
285 if ((stages > 0) && (level >= 4)) {
287 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
289 return -1; /* invalid vector */
292 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
295 for (y=0; y < height; y++) {
296 memset (&dst[y*(pitch / 4)], mean, width);
299 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
300 SVQ1_DO_CODEBOOK_INTRA()
307 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
311 const uint32_t *codebook;
315 int x, y, width, height, level;
316 uint32_t n1, n2, n3, n4;
318 /* initialize list for breadth first processing of vectors */
321 /* recursively process vector */
322 for (i=0, m=1, n=1, level=5; i < n; i++) {
323 SVQ1_PROCESS_VECTOR();
325 /* destination address and vector size */
326 dst = (uint32_t *) list[i];
327 width = 1 << ((4 + level) /2);
328 height = 1 << ((3 + level) /2);
330 /* get number of stages (-1 skips vector, 0 for mean only) */
331 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
333 if (stages == -1) continue; /* skip vector */
335 if ((stages > 0) && (level >= 4)) {
337 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
339 return -1; /* invalid vector */
342 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
344 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
345 SVQ1_DO_CODEBOOK_NONINTRA()
350 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
354 for (i=0; i < 2; i++) {
356 /* get motion code */
357 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
361 if(get_bits1(bitbuf)) diff= -diff;
364 /* add median of motion vector predictors and clip result */
366 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
368 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
374 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
379 src = &previous[x + y*pitch];
382 for (i=0; i < 16; i++) {
383 memcpy (dst, src, 16);
389 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
390 uint8_t *current, uint8_t *previous, int pitch,
391 svq1_pmv_t *motion, int x, int y) {
398 /* predict and decode motion vector */
405 pmv[1] = &motion[(x / 8) + 2];
406 pmv[2] = &motion[(x / 8) + 4];
409 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
415 motion[(x / 8) + 2].x =
416 motion[(x / 8) + 3].x = mv.x;
418 motion[(x / 8) + 2].y =
419 motion[(x / 8) + 3].y = mv.y;
421 if(y + (mv.y >> 1)<0)
423 if(x + (mv.x >> 1)<0)
427 int w= (s->width+15)&~15;
428 int h= (s->height+15)&~15;
429 if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
430 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
433 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
436 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
441 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
442 uint8_t *current, uint8_t *previous, int pitch,
443 svq1_pmv_t *motion,int x, int y) {
450 /* predict and decode motion vector (0) */
457 pmv[1] = &motion[(x / 8) + 2];
458 pmv[2] = &motion[(x / 8) + 4];
461 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
466 /* predict and decode motion vector (1) */
473 pmv[1] = &motion[(x / 8) + 3];
475 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
480 /* predict and decode motion vector (2) */
482 pmv[2] = &motion[(x / 8) + 1];
484 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
489 /* predict and decode motion vector (3) */
490 pmv[2] = &motion[(x / 8) + 2];
491 pmv[3] = &motion[(x / 8) + 3];
493 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
498 /* form predictions */
499 for (i=0; i < 4; i++) {
500 int mvx= pmv[i]->x + (i&1)*16;
501 int mvy= pmv[i]->y + (i>>1)*16;
503 ///XXX /FIXME cliping or padding?
510 int w= (s->width+15)&~15;
511 int h= (s->height+15)&~15;
512 if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
513 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
515 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
518 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
520 /* select next block */
522 current += 8*(pitch - 1);
531 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
532 uint8_t *current, uint8_t *previous, int pitch,
533 svq1_pmv_t *motion, int x, int y) {
538 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
540 /* reset motion vectors */
541 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
544 motion[(x / 8) + 2].x =
545 motion[(x / 8) + 2].y =
546 motion[(x / 8) + 3].x =
547 motion[(x / 8) + 3].y = 0;
550 switch (block_type) {
551 case SVQ1_BLOCK_SKIP:
552 svq1_skip_block (current, previous, pitch, x, y);
555 case SVQ1_BLOCK_INTER:
556 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
561 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
565 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
568 case SVQ1_BLOCK_INTER_4V:
569 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
574 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
578 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
581 case SVQ1_BLOCK_INTRA:
582 result = svq1_decode_block_intra (bitbuf, current, pitch);
589 /* standard video sizes */
590 static struct { int width; int height; } svq1_frame_size_table[8] = {
591 { 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 },
592 { 704, 576 }, { 240, 180 }, { 320, 240 }, { -1, -1 }
595 static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
598 for (i=0; i < length; i++) {
599 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
605 #if 0 /* unused, remove? */
606 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
607 int width, int height, int value) {
610 for (y=0; y < height; y++) {
611 for (x=0; x < width; x++) {
612 value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
622 #ifdef CONFIG_DECODERS
623 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
627 out[0] = get_bits (bitbuf, 8);
629 seed = string_table[out[0]];
631 for (i=1; i <= out[0]; i++) {
632 out[i] = get_bits (bitbuf, 8) ^ seed;
633 seed = string_table[out[i] ^ seed];
637 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
639 int temporal_reference;
641 temporal_reference = get_bits (bitbuf, 8);
644 s->pict_type= get_bits (bitbuf, 2)+1;
648 if (s->pict_type == I_TYPE) {
651 if (s->f_code == 0x50 || s->f_code == 0x60) {
652 int csum = get_bits (bitbuf, 16);
654 csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
656 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
657 // (csum == 0) ? "correct" : "incorrect", csum);
660 if ((s->f_code ^ 0x10) >= 0x50) {
663 svq1_parse_string (bitbuf, msg);
665 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
668 skip_bits (bitbuf, 2);
669 skip_bits (bitbuf, 2);
672 /* load frame size */
673 frame_size_code = get_bits (bitbuf, 3);
675 if (frame_size_code == 7) {
676 /* load width, height (12 bits each) */
677 s->width = get_bits (bitbuf, 12);
678 s->height = get_bits (bitbuf, 12);
680 if (!s->width || !s->height)
683 /* get width, height from table */
684 s->width = svq1_frame_size_table[frame_size_code].width;
685 s->height = svq1_frame_size_table[frame_size_code].height;
690 if (get_bits (bitbuf, 1) == 1) {
691 skip_bits1 (bitbuf); /* use packet checksum if (1) */
692 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
694 if (get_bits (bitbuf, 2) != 0)
698 if (get_bits (bitbuf, 1) == 1) {
700 skip_bits (bitbuf, 4);
702 skip_bits (bitbuf, 2);
704 while (get_bits (bitbuf, 1) == 1) {
705 skip_bits (bitbuf, 8);
712 static int svq1_decode_frame(AVCodecContext *avctx,
713 void *data, int *data_size,
714 uint8_t *buf, int buf_size)
716 MpegEncContext *s=avctx->priv_data;
717 uint8_t *current, *previous;
718 int result, i, x, y, width, height;
719 AVFrame *pict = data;
721 /* initialize bit buffer */
722 init_get_bits(&s->gb,buf,buf_size*8);
724 /* decode frame header */
725 s->f_code = get_bits (&s->gb, 22);
727 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
730 /* swap some header bytes (why?) */
731 if (s->f_code != 0x20) {
732 uint32_t *src = (uint32_t *) (buf + 4);
734 for (i=0; i < 4; i++) {
735 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
739 result = svq1_decode_frame_header (&s->gb, s);
744 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
749 //FIXME this avoids some confusion for "B frames" without 2 references
750 //this should be removed after libavcodec can handle more flexible picture types & ordering
751 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
753 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
754 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
755 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
756 || avctx->skip_frame >= AVDISCARD_ALL)
759 if(MPV_frame_start(s, avctx) < 0)
762 /* decode y, u and v components */
763 for (i=0; i < 3; i++) {
766 width = (s->width+15)&~15;
767 height = (s->height+15)&~15;
768 linesize= s->linesize;
770 if(s->flags&CODEC_FLAG_GRAY) break;
771 width = (s->width/4+15)&~15;
772 height = (s->height/4+15)&~15;
773 linesize= s->uvlinesize;
776 current = s->current_picture.data[i];
778 if(s->pict_type==B_TYPE){
779 previous = s->next_picture.data[i];
781 previous = s->last_picture.data[i];
784 if (s->pict_type == I_TYPE) {
786 for (y=0; y < height; y+=16) {
787 for (x=0; x < width; x+=16) {
788 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
792 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
797 current += 16*linesize;
800 svq1_pmv_t pmv[width/8+3];
802 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
804 for (y=0; y < height; y+=16) {
805 for (x=0; x < width; x+=16) {
806 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
807 linesize, pmv, x, y);
811 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
820 current += 16*linesize;
825 *pict = *(AVFrame*)&s->current_picture;
830 *data_size=sizeof(AVFrame);
834 static int svq1_decode_init(AVCodecContext *avctx)
836 MpegEncContext *s = avctx->priv_data;
839 MPV_decode_defaults(s);
842 s->width = (avctx->width+3)&~3;
843 s->height = (avctx->height+3)&~3;
844 s->codec_id= avctx->codec->id;
845 avctx->pix_fmt = PIX_FMT_YUV410P;
846 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
847 s->flags= avctx->flags;
848 if (MPV_common_init(s) < 0) return -1;
850 init_vlc(&svq1_block_type, 2, 4,
851 &svq1_block_type_vlc[0][1], 2, 1,
852 &svq1_block_type_vlc[0][0], 2, 1, 1);
854 init_vlc(&svq1_motion_component, 7, 33,
856 &mvtab[0][0], 2, 1, 1);
858 for (i = 0; i < 6; i++) {
859 init_vlc(&svq1_intra_multistage[i], 3, 8,
860 &svq1_intra_multistage_vlc[i][0][1], 2, 1,
861 &svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
862 init_vlc(&svq1_inter_multistage[i], 3, 8,
863 &svq1_inter_multistage_vlc[i][0][1], 2, 1,
864 &svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
867 init_vlc(&svq1_intra_mean, 8, 256,
868 &svq1_intra_mean_vlc[0][1], 4, 2,
869 &svq1_intra_mean_vlc[0][0], 4, 2, 1);
871 init_vlc(&svq1_inter_mean, 9, 512,
872 &svq1_inter_mean_vlc[0][1], 4, 2,
873 &svq1_inter_mean_vlc[0][0], 4, 2, 1);
878 static int svq1_decode_end(AVCodecContext *avctx)
880 MpegEncContext *s = avctx->priv_data;
885 #endif /* CONFIG_DECODERS */
887 #ifdef CONFIG_ENCODERS
888 static void svq1_write_header(SVQ1Context *s, int frame_type)
893 put_bits(&s->pb, 22, 0x20);
895 /* temporal reference (sure hope this is a "don't care") */
896 put_bits(&s->pb, 8, 0x00);
899 put_bits(&s->pb, 2, frame_type - 1);
901 if (frame_type == I_TYPE) {
903 /* no checksum since frame code is 0x20 */
905 /* no embedded string either */
907 /* output 5 unknown bits (2 + 2 + 1) */
908 put_bits(&s->pb, 5, 2); /* 2 needed by quicktime decoder */
910 for (i = 0; i < 7; i++)
912 if ((svq1_frame_size_table[i].width == s->frame_width) &&
913 (svq1_frame_size_table[i].height == s->frame_height))
915 put_bits(&s->pb, 3, i);
922 put_bits(&s->pb, 3, 7);
923 put_bits(&s->pb, 12, s->frame_width);
924 put_bits(&s->pb, 12, s->frame_height);
928 /* no checksum or extra data (next 2 bits get 0) */
929 put_bits(&s->pb, 2, 0);
933 #define QUALITY_THRESHOLD 100
934 #define THRESHOLD_MULTIPLIER 0.6
936 #if defined(HAVE_ALTIVEC)
940 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){
941 int count, y, x, i, j, split, best_mean, best_score, best_count;
943 int block_sum[7]= {0, 0, 0, 0, 0, 0};
944 int w= 2<<((level+2)>>1);
945 int h= 2<<((level+1)>>1);
947 int16_t block[7][256];
948 const int8_t *codebook_sum, *codebook;
949 const uint16_t (*mean_vlc)[2];
950 const uint8_t (*multistage_vlc)[2];
953 //FIXME optimize, this doenst need to be done multiple times
955 codebook_sum= svq1_intra_codebook_sum[level];
956 codebook= svq1_intra_codebooks[level];
957 mean_vlc= svq1_intra_mean_vlc;
958 multistage_vlc= svq1_intra_multistage_vlc[level];
961 int v= src[x + y*stride];
962 block[0][x + w*y]= v;
968 codebook_sum= svq1_inter_codebook_sum[level];
969 codebook= svq1_inter_codebooks[level];
970 mean_vlc= svq1_inter_mean_vlc + 256;
971 multistage_vlc= svq1_inter_multistage_vlc[level];
974 int v= src[x + y*stride] - ref[x + y*stride];
975 block[0][x + w*y]= v;
983 best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
984 best_mean= (block_sum[0] + (size>>1)) >> (level+3);
987 for(count=1; count<7; count++){
988 int best_vector_score= INT_MAX;
989 int best_vector_sum=-999, best_vector_mean=-999;
990 const int stage= count-1;
991 const int8_t *vector;
994 int sum= codebook_sum[stage*16 + i];
996 int diff, mean, score;
998 vector = codebook + stage*size*16 + i*size;
1000 for(j=0; j<size; j++){
1002 sqr += (v - block[stage][j])*(v - block[stage][j]);
1004 diff= block_sum[stage] - sum;
1005 mean= (diff + (size>>1)) >> (level+3);
1006 assert(mean >-300 && mean<300);
1007 if(intra) mean= clip(mean, 0, 255);
1008 else mean= clip(mean, -256, 255);
1009 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1010 if(score < best_vector_score){
1011 best_vector_score= score;
1012 best_vector[stage]= i;
1013 best_vector_sum= sum;
1014 best_vector_mean= mean;
1017 assert(best_vector_mean != -999);
1018 vector= codebook + stage*size*16 + best_vector[stage]*size;
1019 for(j=0; j<size; j++){
1020 block[stage+1][j] = block[stage][j] - vector[j];
1022 block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1023 best_vector_score +=
1024 lambda*(+ 1 + 4*count
1025 + multistage_vlc[1+count][1]
1026 + mean_vlc[best_vector_mean][1]);
1028 if(best_vector_score < best_score){
1029 best_score= best_vector_score;
1031 best_mean= best_vector_mean;
1037 if(best_score > threshold && level){
1039 int offset= (level&1) ? stride*h/2 : w/2;
1040 PutBitContext backup[6];
1042 for(i=level-1; i>=0; i--){
1043 backup[i]= s->reorder_pb[i];
1045 score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
1046 score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1049 if(score < best_score){
1053 for(i=level-1; i>=0; i--){
1054 s->reorder_pb[i]= backup[i];
1059 put_bits(&s->reorder_pb[level], 1, split);
1062 assert((best_mean >= 0 && best_mean<256) || !intra);
1063 assert(best_mean >= -256 && best_mean<256);
1064 assert(best_count >=0 && best_count<7);
1065 assert(level<4 || best_count==0);
1067 /* output the encoding */
1068 put_bits(&s->reorder_pb[level],
1069 multistage_vlc[1 + best_count][1],
1070 multistage_vlc[1 + best_count][0]);
1071 put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1072 mean_vlc[best_mean][0]);
1074 for (i = 0; i < best_count; i++){
1075 assert(best_vector[i]>=0 && best_vector[i]<16);
1076 put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1081 decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1090 static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1091 int width, int height, int src_stride, int stride)
1095 int block_width, block_height;
1098 const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1100 /* figure out the acceptable level thresholds in advance */
1101 threshold[5] = QUALITY_THRESHOLD;
1102 for (level = 4; level >= 0; level--)
1103 threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1105 block_width = (width + 15) / 16;
1106 block_height = (height + 15) / 16;
1108 if(s->picture.pict_type == P_TYPE){
1109 s->m.avctx= s->avctx;
1110 s->m.current_picture_ptr= &s->m.current_picture;
1111 s->m.last_picture_ptr = &s->m.last_picture;
1112 s->m.last_picture.data[0]= ref_plane;
1114 s->m.last_picture.linesize[0]=
1115 s->m.new_picture.linesize[0]=
1116 s->m.current_picture.linesize[0]= stride;
1118 s->m.height= height;
1119 s->m.mb_width= block_width;
1120 s->m.mb_height= block_height;
1121 s->m.mb_stride= s->m.mb_width+1;
1122 s->m.b8_stride= 2*s->m.mb_width+1;
1124 s->m.pict_type= s->picture.pict_type;
1125 s->m.me_method= s->avctx->me_method;
1126 s->m.me.scene_change_score=0;
1127 s->m.flags= s->avctx->flags;
1128 // s->m.out_format = FMT_H263;
1129 // s->m.unrestricted_mv= 1;
1131 s->m.lambda= s->picture.quality;
1132 s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1133 s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1135 if(!s->motion_val8[plane]){
1136 s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1137 s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1140 s->m.mb_type= s->mb_type;
1142 //dummies, to avoid segfaults
1143 s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
1144 s->m.current_picture.mb_var= (uint16_t*)s->dummy;
1145 s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1146 s->m.current_picture.mb_type= s->dummy;
1148 s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1149 s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1150 s->m.dsp= s->dsp; //move
1153 s->m.me.dia_size= s->avctx->dia_size;
1154 s->m.first_slice_line=1;
1155 for (y = 0; y < block_height; y++) {
1156 uint8_t src[stride*16];
1158 s->m.new_picture.data[0]= src - y*16*stride; //ugly
1161 for(i=0; i<16 && i + 16*y<height; i++){
1162 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1163 for(x=width; x<16*block_width; x++)
1164 src[i*stride+x]= src[i*stride+x-1];
1166 for(; i<16 && i + 16*y<16*block_height; i++)
1167 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1169 for (x = 0; x < block_width; x++) {
1171 ff_init_block_index(&s->m);
1172 ff_update_block_index(&s->m);
1174 ff_estimate_p_frame_motion(&s->m, x, y);
1176 s->m.first_slice_line=0;
1179 ff_fix_long_p_mvs(&s->m);
1180 ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1183 s->m.first_slice_line=1;
1184 for (y = 0; y < block_height; y++) {
1185 uint8_t src[stride*16];
1187 for(i=0; i<16 && i + 16*y<height; i++){
1188 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1189 for(x=width; x<16*block_width; x++)
1190 src[i*stride+x]= src[i*stride+x-1];
1192 for(; i<16 && i + 16*y<16*block_height; i++)
1193 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1196 for (x = 0; x < block_width; x++) {
1197 uint8_t reorder_buffer[3][6][7*32];
1199 int offset = y * 16 * stride + x * 16;
1200 uint8_t *decoded= decoded_plane + offset;
1201 uint8_t *ref= ref_plane + offset;
1202 int score[4]={0,0,0,0}, best;
1203 uint8_t temp[16*stride];
1205 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
1206 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1211 ff_init_block_index(&s->m);
1212 ff_update_block_index(&s->m);
1214 if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1216 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1218 if(s->picture.pict_type == P_TYPE){
1219 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1220 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1221 score[0]= vlc[1]*lambda;
1223 score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1225 count[0][i]= put_bits_count(&s->reorder_pb[i]);
1226 flush_put_bits(&s->reorder_pb[i]);
1233 if(s->picture.pict_type == P_TYPE){
1234 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1235 int mx, my, pred_x, pred_y, dxy;
1236 int16_t *motion_ptr;
1238 motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1239 if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1241 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1243 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1245 s->m.pb= s->reorder_pb[5];
1248 assert(mx>=-32 && mx<=31);
1249 assert(my>=-32 && my<=31);
1250 assert(pred_x>=-32 && pred_x<=31);
1251 assert(pred_y>=-32 && pred_y<=31);
1252 ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1253 ff_h263_encode_motion(&s->m, my - pred_y, 1);
1254 s->reorder_pb[5]= s->m.pb;
1255 score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1257 dxy= (mx&1) + 2*(my&1);
1259 s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1261 score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1262 best= score[1] <= score[0];
1264 vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1265 score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1266 score[2]+= vlc[1]*lambda;
1267 if(score[2] < score[best] && mx==0 && my==0){
1269 s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1273 put_bits(&s->pb, vlc[1], vlc[0]);
1279 count[1][i]= put_bits_count(&s->reorder_pb[i]);
1280 flush_put_bits(&s->reorder_pb[i]);
1283 motion_ptr[0 ] = motion_ptr[1 ]=
1284 motion_ptr[2 ] = motion_ptr[3 ]=
1285 motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1286 motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1290 s->rd_total += score[best];
1292 for(i=5; i>=0; i--){
1293 ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1296 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1299 s->m.first_slice_line=0;
1304 static int svq1_encode_init(AVCodecContext *avctx)
1306 SVQ1Context * const s = avctx->priv_data;
1308 dsputil_init(&s->dsp, avctx);
1309 avctx->coded_frame= (AVFrame*)&s->picture;
1311 s->frame_width = avctx->width;
1312 s->frame_height = avctx->height;
1314 s->y_block_width = (s->frame_width + 15) / 16;
1315 s->y_block_height = (s->frame_height + 15) / 16;
1317 s->c_block_width = (s->frame_width / 4 + 15) / 16;
1318 s->c_block_height = (s->frame_height / 4 + 15) / 16;
1322 s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
1323 s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1324 s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1325 s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1326 s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1327 h263_encode_init(&s->m); //mv_penalty
1332 static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
1333 int buf_size, void *data)
1335 SVQ1Context * const s = avctx->priv_data;
1336 AVFrame *pict = data;
1337 AVFrame * const p= (AVFrame*)&s->picture;
1341 if(avctx->pix_fmt != PIX_FMT_YUV410P){
1342 av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1346 if(!s->current_picture.data[0]){
1347 avctx->get_buffer(avctx, &s->current_picture);
1348 avctx->get_buffer(avctx, &s->last_picture);
1351 temp= s->current_picture;
1352 s->current_picture= s->last_picture;
1353 s->last_picture= temp;
1355 init_put_bits(&s->pb, buf, buf_size);
1358 p->pict_type = avctx->gop_size && avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1359 p->key_frame = p->pict_type == I_TYPE;
1361 svq1_write_header(s, p->pict_type);
1363 if(svq1_encode_plane(s, i,
1364 s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1365 s->frame_width / (i?4:1), s->frame_height / (i?4:1),
1366 s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
1370 // align_put_bits(&s->pb);
1371 while(put_bits_count(&s->pb) & 31)
1372 put_bits(&s->pb, 1, 0);
1374 flush_put_bits(&s->pb);
1376 return (put_bits_count(&s->pb) / 8);
1379 static int svq1_encode_end(AVCodecContext *avctx)
1381 SVQ1Context * const s = avctx->priv_data;
1384 av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1386 av_freep(&s->m.me.scratchpad);
1387 av_freep(&s->m.me.map);
1388 av_freep(&s->m.me.score_map);
1389 av_freep(&s->mb_type);
1390 av_freep(&s->dummy);
1393 av_freep(&s->motion_val8[i]);
1394 av_freep(&s->motion_val16[i]);
1400 #endif //CONFIG_ENCODERS
1402 #ifdef CONFIG_DECODERS
1403 AVCodec svq1_decoder = {
1407 sizeof(MpegEncContext),
1413 .flush= ff_mpeg_flush,
1414 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1418 #ifdef CONFIG_ENCODERS
1420 AVCodec svq1_encoder = {
1424 sizeof(SVQ1Context),
1428 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1431 #endif //CONFIG_ENCODERS