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 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
604 int width, int height, int value) {
607 for (y=0; y < height; y++) {
608 for (x=0; x < width; x++) {
609 value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
618 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
622 out[0] = get_bits (bitbuf, 8);
624 seed = string_table[out[0]];
626 for (i=1; i <= out[0]; i++) {
627 out[i] = get_bits (bitbuf, 8) ^ seed;
628 seed = string_table[out[i] ^ seed];
632 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
634 int temporal_reference;
636 temporal_reference = get_bits (bitbuf, 8);
639 s->pict_type= get_bits (bitbuf, 2)+1;
643 if (s->pict_type == I_TYPE) {
646 if (s->f_code == 0x50 || s->f_code == 0x60) {
647 int csum = get_bits (bitbuf, 16);
649 csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
651 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
652 // (csum == 0) ? "correct" : "incorrect", csum);
655 if ((s->f_code ^ 0x10) >= 0x50) {
658 svq1_parse_string (bitbuf, (char *) msg);
660 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
663 skip_bits (bitbuf, 2);
664 skip_bits (bitbuf, 2);
667 /* load frame size */
668 frame_size_code = get_bits (bitbuf, 3);
670 if (frame_size_code == 7) {
671 /* load width, height (12 bits each) */
672 s->width = get_bits (bitbuf, 12);
673 s->height = get_bits (bitbuf, 12);
675 if (!s->width || !s->height)
678 /* get width, height from table */
679 s->width = svq1_frame_size_table[frame_size_code].width;
680 s->height = svq1_frame_size_table[frame_size_code].height;
685 if (get_bits (bitbuf, 1) == 1) {
686 skip_bits1 (bitbuf); /* use packet checksum if (1) */
687 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
689 if (get_bits (bitbuf, 2) != 0)
693 if (get_bits (bitbuf, 1) == 1) {
695 skip_bits (bitbuf, 4);
697 skip_bits (bitbuf, 2);
699 while (get_bits (bitbuf, 1) == 1) {
700 skip_bits (bitbuf, 8);
707 static int svq1_decode_frame(AVCodecContext *avctx,
708 void *data, int *data_size,
709 uint8_t *buf, int buf_size)
711 MpegEncContext *s=avctx->priv_data;
712 uint8_t *current, *previous;
713 int result, i, x, y, width, height;
714 AVFrame *pict = data;
716 if(buf==NULL && buf_size==0){
720 /* initialize bit buffer */
721 init_get_bits(&s->gb,buf,buf_size*8);
723 /* decode frame header */
724 s->f_code = get_bits (&s->gb, 22);
726 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
729 /* swap some header bytes (why?) */
730 if (s->f_code != 0x20) {
731 uint32_t *src = (uint32_t *) (buf + 4);
733 for (i=0; i < 4; i++) {
734 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
738 result = svq1_decode_frame_header (&s->gb, s);
743 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
748 //FIXME this avoids some confusion for "B frames" without 2 references
749 //this should be removed after libavcodec can handle more flexible picture types & ordering
750 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
752 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
754 if(MPV_frame_start(s, avctx) < 0)
757 /* decode y, u and v components */
758 for (i=0; i < 3; i++) {
761 width = (s->width+15)&~15;
762 height = (s->height+15)&~15;
763 linesize= s->linesize;
765 if(s->flags&CODEC_FLAG_GRAY) break;
766 width = (s->width/4+15)&~15;
767 height = (s->height/4+15)&~15;
768 linesize= s->uvlinesize;
771 current = s->current_picture.data[i];
773 if(s->pict_type==B_TYPE){
774 previous = s->next_picture.data[i];
776 previous = s->last_picture.data[i];
779 if (s->pict_type == I_TYPE) {
781 for (y=0; y < height; y+=16) {
782 for (x=0; x < width; x+=16) {
783 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
787 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
792 current += 16*linesize;
795 svq1_pmv_t pmv[width/8+3];
797 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
799 for (y=0; y < height; y+=16) {
800 for (x=0; x < width; x+=16) {
801 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
802 linesize, pmv, x, y);
806 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
815 current += 16*linesize;
820 *pict = *(AVFrame*)&s->current_picture;
825 *data_size=sizeof(AVFrame);
829 static int svq1_decode_init(AVCodecContext *avctx)
831 MpegEncContext *s = avctx->priv_data;
834 MPV_decode_defaults(s);
837 s->width = (avctx->width+3)&~3;
838 s->height = (avctx->height+3)&~3;
839 s->codec_id= avctx->codec->id;
840 avctx->pix_fmt = PIX_FMT_YUV410P;
841 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
842 s->flags= avctx->flags;
843 if (MPV_common_init(s) < 0) return -1;
845 init_vlc(&svq1_block_type, 2, 4,
846 &svq1_block_type_vlc[0][1], 2, 1,
847 &svq1_block_type_vlc[0][0], 2, 1);
849 init_vlc(&svq1_motion_component, 7, 33,
853 for (i = 0; i < 6; i++) {
854 init_vlc(&svq1_intra_multistage[i], 3, 8,
855 &svq1_intra_multistage_vlc[i][0][1], 2, 1,
856 &svq1_intra_multistage_vlc[i][0][0], 2, 1);
857 init_vlc(&svq1_inter_multistage[i], 3, 8,
858 &svq1_inter_multistage_vlc[i][0][1], 2, 1,
859 &svq1_inter_multistage_vlc[i][0][0], 2, 1);
862 init_vlc(&svq1_intra_mean, 8, 256,
863 &svq1_intra_mean_vlc[0][1], 4, 2,
864 &svq1_intra_mean_vlc[0][0], 4, 2);
866 init_vlc(&svq1_inter_mean, 9, 512,
867 &svq1_inter_mean_vlc[0][1], 4, 2,
868 &svq1_inter_mean_vlc[0][0], 4, 2);
873 static int svq1_decode_end(AVCodecContext *avctx)
875 MpegEncContext *s = avctx->priv_data;
881 static void svq1_write_header(SVQ1Context *s, int frame_type)
886 put_bits(&s->pb, 22, 0x20);
888 /* temporal reference (sure hope this is a "don't care") */
889 put_bits(&s->pb, 8, 0x00);
892 put_bits(&s->pb, 2, frame_type - 1);
894 if (frame_type == I_TYPE) {
896 /* no checksum since frame code is 0x20 */
898 /* no embedded string either */
900 /* output 5 unknown bits (2 + 2 + 1) */
901 put_bits(&s->pb, 5, 0);
903 for (i = 0; i < 7; i++)
905 if ((svq1_frame_size_table[i].width == s->frame_width) &&
906 (svq1_frame_size_table[i].height == s->frame_height))
908 put_bits(&s->pb, 3, i);
915 put_bits(&s->pb, 3, 7);
916 put_bits(&s->pb, 12, s->frame_width);
917 put_bits(&s->pb, 12, s->frame_height);
921 /* no checksum or extra data (next 2 bits get 0) */
922 put_bits(&s->pb, 2, 0);
926 #define QUALITY_THRESHOLD 100
927 #define THRESHOLD_MULTIPLIER 0.6
929 #if defined(HAVE_ALTIVEC)
933 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){
934 int count, y, x, i, j, split, best_mean, best_score, best_count;
936 int block_sum[7]= {0, 0, 0, 0, 0, 0};
937 int w= 2<<((level+2)>>1);
938 int h= 2<<((level+1)>>1);
940 int16_t block[7][256];
941 const int8_t *codebook_sum, *codebook;
942 const uint16_t (*mean_vlc)[2];
943 const uint8_t (*multistage_vlc)[2];
946 //FIXME optimize, this doenst need to be done multiple times
948 codebook_sum= svq1_intra_codebook_sum[level];
949 codebook= svq1_intra_codebooks[level];
950 mean_vlc= svq1_intra_mean_vlc;
951 multistage_vlc= svq1_intra_multistage_vlc[level];
954 int v= src[x + y*stride];
955 block[0][x + w*y]= v;
961 codebook_sum= svq1_inter_codebook_sum[level];
962 codebook= svq1_inter_codebooks[level];
963 mean_vlc= svq1_inter_mean_vlc + 256;
964 multistage_vlc= svq1_inter_multistage_vlc[level];
967 int v= src[x + y*stride] - ref[x + y*stride];
968 block[0][x + w*y]= v;
976 best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
977 best_mean= (block_sum[0] + (size>>1)) >> (level+3);
980 for(count=1; count<7; count++){
981 int best_vector_score= INT_MAX;
982 int best_vector_sum=-999, best_vector_mean=-999;
983 const int stage= count-1;
984 const int8_t *vector;
987 int sum= codebook_sum[stage*16 + i];
989 int diff, mean, score;
991 vector = codebook + stage*size*16 + i*size;
993 for(j=0; j<size; j++){
995 sqr += (v - block[stage][j])*(v - block[stage][j]);
997 diff= block_sum[stage] - sum;
998 mean= (diff + (size>>1)) >> (level+3);
999 assert(mean >-300 && mean<300);
1000 if(intra) mean= clip(mean, 0, 255);
1001 else mean= clip(mean, -256, 255);
1002 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1003 if(score < best_vector_score){
1004 best_vector_score= score;
1005 best_vector[stage]= i;
1006 best_vector_sum= sum;
1007 best_vector_mean= mean;
1010 assert(best_vector_mean != -999);
1011 vector= codebook + stage*size*16 + best_vector[stage]*size;
1012 for(j=0; j<size; j++){
1013 block[stage+1][j] = block[stage][j] - vector[j];
1015 block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1016 best_vector_score +=
1017 lambda*(+ 1 + 4*count
1018 + multistage_vlc[1+count][1]
1019 + mean_vlc[best_vector_mean][1]);
1021 if(best_vector_score < best_score){
1022 best_score= best_vector_score;
1024 best_mean= best_vector_mean;
1030 if(best_score > threshold && level){
1032 int offset= (level&1) ? stride*h/2 : w/2;
1033 PutBitContext backup[6];
1035 for(i=level-1; i>=0; i--){
1036 backup[i]= s->reorder_pb[i];
1038 score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
1039 score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1042 if(score < best_score){
1046 for(i=level-1; i>=0; i--){
1047 s->reorder_pb[i]= backup[i];
1052 put_bits(&s->reorder_pb[level], 1, split);
1055 assert((best_mean >= 0 && best_mean<256) || !intra);
1056 assert(best_mean >= -256 && best_mean<256);
1057 assert(best_count >=0 && best_count<7);
1058 assert(level<4 || best_count==0);
1060 /* output the encoding */
1061 put_bits(&s->reorder_pb[level],
1062 multistage_vlc[1 + best_count][1],
1063 multistage_vlc[1 + best_count][0]);
1064 put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1065 mean_vlc[best_mean][0]);
1067 for (i = 0; i < best_count; i++){
1068 assert(best_vector[i]>=0 && best_vector[i]<16);
1069 put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1074 decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1082 #ifdef CONFIG_ENCODERS
1084 static void svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1085 int width, int height, int src_stride, int stride)
1089 int block_width, block_height;
1092 const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1094 /* figure out the acceptable level thresholds in advance */
1095 threshold[5] = QUALITY_THRESHOLD;
1096 for (level = 4; level >= 0; level--)
1097 threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1099 block_width = (width + 15) / 16;
1100 block_height = (height + 15) / 16;
1102 if(s->picture.pict_type == P_TYPE){
1103 s->m.avctx= s->avctx;
1104 s->m.current_picture_ptr= &s->m.current_picture;
1105 s->m.last_picture_ptr = &s->m.last_picture;
1106 s->m.last_picture.data[0]= ref_plane;
1108 s->m.last_picture.linesize[0]=
1109 s->m.new_picture.linesize[0]=
1110 s->m.current_picture.linesize[0]= stride;
1112 s->m.height= height;
1113 s->m.mb_width= block_width;
1114 s->m.mb_height= block_height;
1115 s->m.mb_stride= s->m.mb_width+1;
1116 s->m.b8_stride= 2*s->m.mb_width+1;
1118 s->m.pict_type= s->picture.pict_type;
1119 s->m.qscale= s->picture.quality/FF_QP2LAMBDA;
1120 s->m.me_method= s->avctx->me_method;
1122 if(!s->motion_val8[plane]){
1123 s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1124 s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1127 s->m.mb_type= s->mb_type;
1129 //dummies, to avoid segfaults
1130 s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
1131 s->m.current_picture.mb_var= (uint16_t*)s->dummy;
1132 s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1133 s->m.current_picture.mb_type= s->dummy;
1135 s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1136 s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1137 s->m.dsp= s->dsp; //move
1140 s->m.me.dia_size= s->avctx->dia_size;
1141 s->m.first_slice_line=1;
1142 for (y = 0; y < block_height; y++) {
1143 uint8_t src[stride*16];
1145 s->m.new_picture.data[0]= src - y*16*stride; //ugly
1148 for(i=0; i<16 && i + 16*y<height; i++){
1149 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1150 for(x=width; x<16*block_width; x++)
1151 src[i*stride+x]= src[i*stride+x-1];
1153 for(; i<16 && i + 16*y<16*block_height; i++)
1154 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1156 for (x = 0; x < block_width; x++) {
1158 ff_init_block_index(&s->m);
1159 ff_update_block_index(&s->m);
1161 ff_estimate_p_frame_motion(&s->m, x, y);
1163 s->m.first_slice_line=0;
1166 ff_fix_long_p_mvs(&s->m);
1167 ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1170 s->m.first_slice_line=1;
1171 for (y = 0; y < block_height; y++) {
1172 uint8_t src[stride*16];
1174 for(i=0; i<16 && i + 16*y<height; i++){
1175 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1176 for(x=width; x<16*block_width; x++)
1177 src[i*stride+x]= src[i*stride+x-1];
1179 for(; i<16 && i + 16*y<16*block_height; i++)
1180 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1183 for (x = 0; x < block_width; x++) {
1184 uint8_t reorder_buffer[3][6][7*32];
1186 int offset = y * 16 * stride + x * 16;
1187 uint8_t *decoded= decoded_plane + offset;
1188 uint8_t *ref= ref_plane + offset;
1189 int score[4]={0,0,0,0}, best;
1190 uint8_t temp[16*stride];
1193 ff_init_block_index(&s->m);
1194 ff_update_block_index(&s->m);
1196 if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1198 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1200 if(s->picture.pict_type == P_TYPE){
1201 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1202 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1203 score[0]= vlc[1]*lambda;
1205 score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1207 count[0][i]= put_bits_count(&s->reorder_pb[i]);
1208 flush_put_bits(&s->reorder_pb[i]);
1215 if(s->picture.pict_type == P_TYPE){
1216 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1217 int mx, my, pred_x, pred_y, dxy;
1218 int16_t *motion_ptr;
1220 motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1221 if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1223 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1225 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1227 s->m.pb= s->reorder_pb[5];
1230 assert(mx>=-32 && mx<=31);
1231 assert(my>=-32 && my<=31);
1232 assert(pred_x>=-32 && pred_x<=31);
1233 assert(pred_y>=-32 && pred_y<=31);
1234 ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1235 ff_h263_encode_motion(&s->m, my - pred_y, 1);
1236 s->reorder_pb[5]= s->m.pb;
1237 score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1239 dxy= (mx&1) + 2*(my&1);
1241 s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1243 score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1244 best= score[1] <= score[0];
1246 vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1247 score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1248 score[2]+= vlc[1]*lambda;
1249 if(score[2] < score[best] && mx==0 && my==0){
1251 s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1255 put_bits(&s->pb, vlc[1], vlc[0]);
1261 count[1][i]= put_bits_count(&s->reorder_pb[i]);
1262 flush_put_bits(&s->reorder_pb[i]);
1265 motion_ptr[0 ] = motion_ptr[1 ]=
1266 motion_ptr[2 ] = motion_ptr[3 ]=
1267 motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1268 motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1272 s->rd_total += score[best];
1274 for(i=5; i>=0; i--){
1275 ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1278 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1281 s->m.first_slice_line=0;
1285 static int svq1_encode_init(AVCodecContext *avctx)
1287 SVQ1Context * const s = avctx->priv_data;
1289 dsputil_init(&s->dsp, avctx);
1290 avctx->coded_frame= (AVFrame*)&s->picture;
1292 s->frame_width = avctx->width;
1293 s->frame_height = avctx->height;
1295 s->y_block_width = (s->frame_width + 15) / 16;
1296 s->y_block_height = (s->frame_height + 15) / 16;
1298 s->c_block_width = (s->frame_width / 4 + 15) / 16;
1299 s->c_block_height = (s->frame_height / 4 + 15) / 16;
1303 s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
1304 s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1305 s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1306 s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1307 s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1308 h263_encode_init(&s->m); //mv_penalty
1313 static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
1314 int buf_size, void *data)
1316 SVQ1Context * const s = avctx->priv_data;
1317 AVFrame *pict = data;
1318 AVFrame * const p= (AVFrame*)&s->picture;
1322 if(avctx->pix_fmt != PIX_FMT_YUV410P){
1323 av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1327 if(!s->current_picture.data[0]){
1328 avctx->get_buffer(avctx, &s->current_picture);
1329 avctx->get_buffer(avctx, &s->last_picture);
1332 temp= s->current_picture;
1333 s->current_picture= s->last_picture;
1334 s->last_picture= temp;
1336 init_put_bits(&s->pb, buf, buf_size);
1339 p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1340 p->key_frame = p->pict_type == I_TYPE;
1342 svq1_write_header(s, p->pict_type);
1344 svq1_encode_plane(s, i,
1345 s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1346 s->frame_width / (i?4:1), s->frame_height / (i?4:1),
1347 s->picture.linesize[i], s->current_picture.linesize[i]);
1350 // align_put_bits(&s->pb);
1351 while(put_bits_count(&s->pb) & 31)
1352 put_bits(&s->pb, 1, 0);
1354 flush_put_bits(&s->pb);
1356 return (put_bits_count(&s->pb) / 8);
1359 static int svq1_encode_end(AVCodecContext *avctx)
1361 SVQ1Context * const s = avctx->priv_data;
1364 av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1366 av_freep(&s->m.me.scratchpad);
1367 av_freep(&s->m.me.map);
1368 av_freep(&s->m.me.score_map);
1369 av_freep(&s->mb_type);
1370 av_freep(&s->dummy);
1373 av_freep(&s->motion_val8[i]);
1374 av_freep(&s->motion_val16[i]);
1380 #endif //CONFIG_ENCODERS
1382 AVCodec svq1_decoder = {
1386 sizeof(MpegEncContext),
1392 .flush= ff_mpeg_flush,
1393 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1396 #ifdef CONFIG_ENCODERS
1398 AVCodec svq1_encoder = {
1402 sizeof(SVQ1Context),
1406 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1409 #endif //CONFIG_ENCODERS