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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
624 out[0] = get_bits (bitbuf, 8);
626 seed = string_table[out[0]];
628 for (i=1; i <= out[0]; i++) {
629 out[i] = get_bits (bitbuf, 8) ^ seed;
630 seed = string_table[out[i] ^ seed];
634 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
636 int temporal_reference;
638 temporal_reference = get_bits (bitbuf, 8);
641 s->pict_type= get_bits (bitbuf, 2)+1;
645 if (s->pict_type == I_TYPE) {
648 if (s->f_code == 0x50 || s->f_code == 0x60) {
649 int csum = get_bits (bitbuf, 16);
651 csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
653 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
654 // (csum == 0) ? "correct" : "incorrect", csum);
657 if ((s->f_code ^ 0x10) >= 0x50) {
660 svq1_parse_string (bitbuf, (char *) msg);
662 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
665 skip_bits (bitbuf, 2);
666 skip_bits (bitbuf, 2);
669 /* load frame size */
670 frame_size_code = get_bits (bitbuf, 3);
672 if (frame_size_code == 7) {
673 /* load width, height (12 bits each) */
674 s->width = get_bits (bitbuf, 12);
675 s->height = get_bits (bitbuf, 12);
677 if (!s->width || !s->height)
680 /* get width, height from table */
681 s->width = svq1_frame_size_table[frame_size_code].width;
682 s->height = svq1_frame_size_table[frame_size_code].height;
687 if (get_bits (bitbuf, 1) == 1) {
688 skip_bits1 (bitbuf); /* use packet checksum if (1) */
689 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
691 if (get_bits (bitbuf, 2) != 0)
695 if (get_bits (bitbuf, 1) == 1) {
697 skip_bits (bitbuf, 4);
699 skip_bits (bitbuf, 2);
701 while (get_bits (bitbuf, 1) == 1) {
702 skip_bits (bitbuf, 8);
709 static int svq1_decode_frame(AVCodecContext *avctx,
710 void *data, int *data_size,
711 uint8_t *buf, int buf_size)
713 MpegEncContext *s=avctx->priv_data;
714 uint8_t *current, *previous;
715 int result, i, x, y, width, height;
716 AVFrame *pict = data;
718 /* initialize bit buffer */
719 init_get_bits(&s->gb,buf,buf_size*8);
721 /* decode frame header */
722 s->f_code = get_bits (&s->gb, 22);
724 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
727 /* swap some header bytes (why?) */
728 if (s->f_code != 0x20) {
729 uint32_t *src = (uint32_t *) (buf + 4);
731 for (i=0; i < 4; i++) {
732 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
736 result = svq1_decode_frame_header (&s->gb, s);
741 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
746 //FIXME this avoids some confusion for "B frames" without 2 references
747 //this should be removed after libavcodec can handle more flexible picture types & ordering
748 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
750 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
752 if(MPV_frame_start(s, avctx) < 0)
755 /* decode y, u and v components */
756 for (i=0; i < 3; i++) {
759 width = (s->width+15)&~15;
760 height = (s->height+15)&~15;
761 linesize= s->linesize;
763 if(s->flags&CODEC_FLAG_GRAY) break;
764 width = (s->width/4+15)&~15;
765 height = (s->height/4+15)&~15;
766 linesize= s->uvlinesize;
769 current = s->current_picture.data[i];
771 if(s->pict_type==B_TYPE){
772 previous = s->next_picture.data[i];
774 previous = s->last_picture.data[i];
777 if (s->pict_type == I_TYPE) {
779 for (y=0; y < height; y+=16) {
780 for (x=0; x < width; x+=16) {
781 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
785 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
790 current += 16*linesize;
793 svq1_pmv_t pmv[width/8+3];
795 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
797 for (y=0; y < height; y+=16) {
798 for (x=0; x < width; x+=16) {
799 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
800 linesize, pmv, x, y);
804 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
813 current += 16*linesize;
818 *pict = *(AVFrame*)&s->current_picture;
823 *data_size=sizeof(AVFrame);
827 static int svq1_decode_init(AVCodecContext *avctx)
829 MpegEncContext *s = avctx->priv_data;
832 MPV_decode_defaults(s);
835 s->width = (avctx->width+3)&~3;
836 s->height = (avctx->height+3)&~3;
837 s->codec_id= avctx->codec->id;
838 avctx->pix_fmt = PIX_FMT_YUV410P;
839 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
840 s->flags= avctx->flags;
841 if (MPV_common_init(s) < 0) return -1;
843 init_vlc(&svq1_block_type, 2, 4,
844 &svq1_block_type_vlc[0][1], 2, 1,
845 &svq1_block_type_vlc[0][0], 2, 1, 1);
847 init_vlc(&svq1_motion_component, 7, 33,
849 &mvtab[0][0], 2, 1, 1);
851 for (i = 0; i < 6; i++) {
852 init_vlc(&svq1_intra_multistage[i], 3, 8,
853 &svq1_intra_multistage_vlc[i][0][1], 2, 1,
854 &svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
855 init_vlc(&svq1_inter_multistage[i], 3, 8,
856 &svq1_inter_multistage_vlc[i][0][1], 2, 1,
857 &svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
860 init_vlc(&svq1_intra_mean, 8, 256,
861 &svq1_intra_mean_vlc[0][1], 4, 2,
862 &svq1_intra_mean_vlc[0][0], 4, 2, 1);
864 init_vlc(&svq1_inter_mean, 9, 512,
865 &svq1_inter_mean_vlc[0][1], 4, 2,
866 &svq1_inter_mean_vlc[0][0], 4, 2, 1);
871 static int svq1_decode_end(AVCodecContext *avctx)
873 MpegEncContext *s = avctx->priv_data;
879 static void svq1_write_header(SVQ1Context *s, int frame_type)
884 put_bits(&s->pb, 22, 0x20);
886 /* temporal reference (sure hope this is a "don't care") */
887 put_bits(&s->pb, 8, 0x00);
890 put_bits(&s->pb, 2, frame_type - 1);
892 if (frame_type == I_TYPE) {
894 /* no checksum since frame code is 0x20 */
896 /* no embedded string either */
898 /* output 5 unknown bits (2 + 2 + 1) */
899 put_bits(&s->pb, 5, 0);
901 for (i = 0; i < 7; i++)
903 if ((svq1_frame_size_table[i].width == s->frame_width) &&
904 (svq1_frame_size_table[i].height == s->frame_height))
906 put_bits(&s->pb, 3, i);
913 put_bits(&s->pb, 3, 7);
914 put_bits(&s->pb, 12, s->frame_width);
915 put_bits(&s->pb, 12, s->frame_height);
919 /* no checksum or extra data (next 2 bits get 0) */
920 put_bits(&s->pb, 2, 0);
924 #define QUALITY_THRESHOLD 100
925 #define THRESHOLD_MULTIPLIER 0.6
927 #if defined(HAVE_ALTIVEC)
931 static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){
932 int count, y, x, i, j, split, best_mean, best_score, best_count;
934 int block_sum[7]= {0, 0, 0, 0, 0, 0};
935 int w= 2<<((level+2)>>1);
936 int h= 2<<((level+1)>>1);
938 int16_t block[7][256];
939 const int8_t *codebook_sum, *codebook;
940 const uint16_t (*mean_vlc)[2];
941 const uint8_t (*multistage_vlc)[2];
944 //FIXME optimize, this doenst need to be done multiple times
946 codebook_sum= svq1_intra_codebook_sum[level];
947 codebook= svq1_intra_codebooks[level];
948 mean_vlc= svq1_intra_mean_vlc;
949 multistage_vlc= svq1_intra_multistage_vlc[level];
952 int v= src[x + y*stride];
953 block[0][x + w*y]= v;
959 codebook_sum= svq1_inter_codebook_sum[level];
960 codebook= svq1_inter_codebooks[level];
961 mean_vlc= svq1_inter_mean_vlc + 256;
962 multistage_vlc= svq1_inter_multistage_vlc[level];
965 int v= src[x + y*stride] - ref[x + y*stride];
966 block[0][x + w*y]= v;
974 best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
975 best_mean= (block_sum[0] + (size>>1)) >> (level+3);
978 for(count=1; count<7; count++){
979 int best_vector_score= INT_MAX;
980 int best_vector_sum=-999, best_vector_mean=-999;
981 const int stage= count-1;
982 const int8_t *vector;
985 int sum= codebook_sum[stage*16 + i];
987 int diff, mean, score;
989 vector = codebook + stage*size*16 + i*size;
991 for(j=0; j<size; j++){
993 sqr += (v - block[stage][j])*(v - block[stage][j]);
995 diff= block_sum[stage] - sum;
996 mean= (diff + (size>>1)) >> (level+3);
997 assert(mean >-300 && mean<300);
998 if(intra) mean= clip(mean, 0, 255);
999 else mean= clip(mean, -256, 255);
1000 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1001 if(score < best_vector_score){
1002 best_vector_score= score;
1003 best_vector[stage]= i;
1004 best_vector_sum= sum;
1005 best_vector_mean= mean;
1008 assert(best_vector_mean != -999);
1009 vector= codebook + stage*size*16 + best_vector[stage]*size;
1010 for(j=0; j<size; j++){
1011 block[stage+1][j] = block[stage][j] - vector[j];
1013 block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1014 best_vector_score +=
1015 lambda*(+ 1 + 4*count
1016 + multistage_vlc[1+count][1]
1017 + mean_vlc[best_vector_mean][1]);
1019 if(best_vector_score < best_score){
1020 best_score= best_vector_score;
1022 best_mean= best_vector_mean;
1028 if(best_score > threshold && level){
1030 int offset= (level&1) ? stride*h/2 : w/2;
1031 PutBitContext backup[6];
1033 for(i=level-1; i>=0; i--){
1034 backup[i]= s->reorder_pb[i];
1036 score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
1037 score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1040 if(score < best_score){
1044 for(i=level-1; i>=0; i--){
1045 s->reorder_pb[i]= backup[i];
1050 put_bits(&s->reorder_pb[level], 1, split);
1053 assert((best_mean >= 0 && best_mean<256) || !intra);
1054 assert(best_mean >= -256 && best_mean<256);
1055 assert(best_count >=0 && best_count<7);
1056 assert(level<4 || best_count==0);
1058 /* output the encoding */
1059 put_bits(&s->reorder_pb[level],
1060 multistage_vlc[1 + best_count][1],
1061 multistage_vlc[1 + best_count][0]);
1062 put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1063 mean_vlc[best_mean][0]);
1065 for (i = 0; i < best_count; i++){
1066 assert(best_vector[i]>=0 && best_vector[i]<16);
1067 put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1072 decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1080 #ifdef CONFIG_ENCODERS
1082 static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1083 int width, int height, int src_stride, int stride)
1087 int block_width, block_height;
1090 const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1092 /* figure out the acceptable level thresholds in advance */
1093 threshold[5] = QUALITY_THRESHOLD;
1094 for (level = 4; level >= 0; level--)
1095 threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1097 block_width = (width + 15) / 16;
1098 block_height = (height + 15) / 16;
1100 if(s->picture.pict_type == P_TYPE){
1101 s->m.avctx= s->avctx;
1102 s->m.current_picture_ptr= &s->m.current_picture;
1103 s->m.last_picture_ptr = &s->m.last_picture;
1104 s->m.last_picture.data[0]= ref_plane;
1106 s->m.last_picture.linesize[0]=
1107 s->m.new_picture.linesize[0]=
1108 s->m.current_picture.linesize[0]= stride;
1110 s->m.height= height;
1111 s->m.mb_width= block_width;
1112 s->m.mb_height= block_height;
1113 s->m.mb_stride= s->m.mb_width+1;
1114 s->m.b8_stride= 2*s->m.mb_width+1;
1116 s->m.pict_type= s->picture.pict_type;
1117 s->m.qscale= s->picture.quality/FF_QP2LAMBDA;
1118 s->m.me_method= s->avctx->me_method;
1120 if(!s->motion_val8[plane]){
1121 s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1122 s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1125 s->m.mb_type= s->mb_type;
1127 //dummies, to avoid segfaults
1128 s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
1129 s->m.current_picture.mb_var= (uint16_t*)s->dummy;
1130 s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1131 s->m.current_picture.mb_type= s->dummy;
1133 s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1134 s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1135 s->m.dsp= s->dsp; //move
1138 s->m.me.dia_size= s->avctx->dia_size;
1139 s->m.first_slice_line=1;
1140 for (y = 0; y < block_height; y++) {
1141 uint8_t src[stride*16];
1143 s->m.new_picture.data[0]= src - y*16*stride; //ugly
1146 for(i=0; i<16 && i + 16*y<height; i++){
1147 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1148 for(x=width; x<16*block_width; x++)
1149 src[i*stride+x]= src[i*stride+x-1];
1151 for(; i<16 && i + 16*y<16*block_height; i++)
1152 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1154 for (x = 0; x < block_width; x++) {
1156 ff_init_block_index(&s->m);
1157 ff_update_block_index(&s->m);
1159 ff_estimate_p_frame_motion(&s->m, x, y);
1161 s->m.first_slice_line=0;
1164 ff_fix_long_p_mvs(&s->m);
1165 ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1168 s->m.first_slice_line=1;
1169 for (y = 0; y < block_height; y++) {
1170 uint8_t src[stride*16];
1172 for(i=0; i<16 && i + 16*y<height; i++){
1173 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1174 for(x=width; x<16*block_width; x++)
1175 src[i*stride+x]= src[i*stride+x-1];
1177 for(; i<16 && i + 16*y<16*block_height; i++)
1178 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1181 for (x = 0; x < block_width; x++) {
1182 uint8_t reorder_buffer[3][6][7*32];
1184 int offset = y * 16 * stride + x * 16;
1185 uint8_t *decoded= decoded_plane + offset;
1186 uint8_t *ref= ref_plane + offset;
1187 int score[4]={0,0,0,0}, best;
1188 uint8_t temp[16*stride];
1190 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
1191 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1196 ff_init_block_index(&s->m);
1197 ff_update_block_index(&s->m);
1199 if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1201 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1203 if(s->picture.pict_type == P_TYPE){
1204 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1205 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1206 score[0]= vlc[1]*lambda;
1208 score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1210 count[0][i]= put_bits_count(&s->reorder_pb[i]);
1211 flush_put_bits(&s->reorder_pb[i]);
1218 if(s->picture.pict_type == P_TYPE){
1219 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1220 int mx, my, pred_x, pred_y, dxy;
1221 int16_t *motion_ptr;
1223 motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1224 if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1226 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1228 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1230 s->m.pb= s->reorder_pb[5];
1233 assert(mx>=-32 && mx<=31);
1234 assert(my>=-32 && my<=31);
1235 assert(pred_x>=-32 && pred_x<=31);
1236 assert(pred_y>=-32 && pred_y<=31);
1237 ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1238 ff_h263_encode_motion(&s->m, my - pred_y, 1);
1239 s->reorder_pb[5]= s->m.pb;
1240 score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1242 dxy= (mx&1) + 2*(my&1);
1244 s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1246 score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1247 best= score[1] <= score[0];
1249 vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1250 score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1251 score[2]+= vlc[1]*lambda;
1252 if(score[2] < score[best] && mx==0 && my==0){
1254 s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1258 put_bits(&s->pb, vlc[1], vlc[0]);
1264 count[1][i]= put_bits_count(&s->reorder_pb[i]);
1265 flush_put_bits(&s->reorder_pb[i]);
1268 motion_ptr[0 ] = motion_ptr[1 ]=
1269 motion_ptr[2 ] = motion_ptr[3 ]=
1270 motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1271 motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1275 s->rd_total += score[best];
1277 for(i=5; i>=0; i--){
1278 ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1281 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1284 s->m.first_slice_line=0;
1289 static int svq1_encode_init(AVCodecContext *avctx)
1291 SVQ1Context * const s = avctx->priv_data;
1293 dsputil_init(&s->dsp, avctx);
1294 avctx->coded_frame= (AVFrame*)&s->picture;
1296 s->frame_width = avctx->width;
1297 s->frame_height = avctx->height;
1299 s->y_block_width = (s->frame_width + 15) / 16;
1300 s->y_block_height = (s->frame_height + 15) / 16;
1302 s->c_block_width = (s->frame_width / 4 + 15) / 16;
1303 s->c_block_height = (s->frame_height / 4 + 15) / 16;
1307 s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
1308 s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1309 s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1310 s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1311 s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1312 h263_encode_init(&s->m); //mv_penalty
1317 static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
1318 int buf_size, void *data)
1320 SVQ1Context * const s = avctx->priv_data;
1321 AVFrame *pict = data;
1322 AVFrame * const p= (AVFrame*)&s->picture;
1326 if(avctx->pix_fmt != PIX_FMT_YUV410P){
1327 av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1331 if(!s->current_picture.data[0]){
1332 avctx->get_buffer(avctx, &s->current_picture);
1333 avctx->get_buffer(avctx, &s->last_picture);
1336 temp= s->current_picture;
1337 s->current_picture= s->last_picture;
1338 s->last_picture= temp;
1340 init_put_bits(&s->pb, buf, buf_size);
1343 p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1344 p->key_frame = p->pict_type == I_TYPE;
1346 svq1_write_header(s, p->pict_type);
1348 if(svq1_encode_plane(s, i,
1349 s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1350 s->frame_width / (i?4:1), s->frame_height / (i?4:1),
1351 s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
1355 // align_put_bits(&s->pb);
1356 while(put_bits_count(&s->pb) & 31)
1357 put_bits(&s->pb, 1, 0);
1359 flush_put_bits(&s->pb);
1361 return (put_bits_count(&s->pb) / 8);
1364 static int svq1_encode_end(AVCodecContext *avctx)
1366 SVQ1Context * const s = avctx->priv_data;
1369 av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1371 av_freep(&s->m.me.scratchpad);
1372 av_freep(&s->m.me.map);
1373 av_freep(&s->m.me.score_map);
1374 av_freep(&s->mb_type);
1375 av_freep(&s->dummy);
1378 av_freep(&s->motion_val8[i]);
1379 av_freep(&s->motion_val16[i]);
1385 #endif //CONFIG_ENCODERS
1387 AVCodec svq1_decoder = {
1391 sizeof(MpegEncContext),
1397 .flush= ff_mpeg_flush,
1398 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1401 #ifdef CONFIG_ENCODERS
1403 AVCodec svq1_encoder = {
1407 sizeof(SVQ1Context),
1411 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1414 #endif //CONFIG_ENCODERS