svq1 mv array size fix
[libav.git] / libavcodec / svq1.c
CommitLineData
36577721
NK
1/*
2 *
be8ffec9 3 * Copyright (C) 2002 the xine project
36577721 4 * Copyright (C) 2002 the ffmpeg project
be8ffec9 5 *
36577721
NK
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
36577721 19 *
3b64893d 20 * (SVQ1 Decoder)
861dfbb5 21 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
be8ffec9 22 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
be8ffec9 23 *
3b64893d 24 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
be8ffec9 25 */
983e3246
MN
26
27/**
28 * @file svq1.c
3b64893d
MM
29 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
30 * For more information of the SVQ1 algorithm, visit:
31 * http://www.pcisys.net/~melanson/codecs/
983e3246
MN
32 */
33
59fcece9 34
be8ffec9
NK
35//#define DEBUG_SVQ1
36#include <stdio.h>
37#include <stdlib.h>
38#include <string.h>
39#include <unistd.h>
fa2ae822 40#include <limits.h>
be8ffec9 41
82dd7d0d 42#include "common.h"
be8ffec9
NK
43#include "avcodec.h"
44#include "dsputil.h"
45#include "mpegvideo.h"
59fcece9 46#include "bswap.h"
be8ffec9 47
fa2ae822
MN
48#undef NDEBUG
49#include <assert.h>
50
5e13a730
MN
51extern const uint8_t mvtab[33][2];
52
59fcece9
MM
53static VLC svq1_block_type;
54static VLC svq1_motion_component;
55static VLC svq1_intra_multistage[6];
56static VLC svq1_inter_multistage[6];
57static VLC svq1_intra_mean;
58static VLC svq1_inter_mean;
be8ffec9 59
be8ffec9
NK
60#define SVQ1_BLOCK_SKIP 0
61#define SVQ1_BLOCK_INTER 1
62#define SVQ1_BLOCK_INTER_4V 2
63#define SVQ1_BLOCK_INTRA 3
64
3b64893d 65typedef struct SVQ1Context {
5e13a730 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)
3b64893d
MM
67 AVCodecContext *avctx;
68 DSPContext dsp;
69 AVFrame picture;
ec6d8af5
MN
70 AVFrame current_picture;
71 AVFrame last_picture;
3b64893d
MM
72 PutBitContext pb;
73 GetBitContext gb;
fa2ae822
MN
74
75 PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
3b64893d
MM
76
77 int frame_width;
78 int frame_height;
79
80 /* Y plane block dimensions */
81 int y_block_width;
82 int y_block_height;
83
84 /* U & V plane (C planes) block dimensions */
85 int c_block_width;
86 int c_block_height;
5e13a730
MN
87
88 uint16_t *mb_type;
89 uint32_t *dummy;
90 int16_t (*motion_val8[3])[2];
91 int16_t (*motion_val16[3])[2];
3b64893d 92
bab97b2f 93 int64_t rd_total;
3b64893d
MM
94} SVQ1Context;
95
be8ffec9
NK
96/* motion vector (prediction) */
97typedef struct svq1_pmv_s {
98 int x;
99 int y;
100} svq1_pmv_t;
101
ce23c668 102#include "svq1_cb.h"
59fcece9
MM
103#include "svq1_vlc.h"
104
105static 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
be8ffec9
NK
138};
139
59fcece9
MM
140static 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
be8ffec9
NK
173};
174
82dd7d0d
NK
175#define SVQ1_PROCESS_VECTOR()\
176 for (; level > 0; i++) {\
177 /* process next depth */\
178 if (i == m) {\
179 m = n;\
180 if (--level == 0)\
181 break;\
182 }\
183 /* divide block if next bit set */\
184 if (get_bits (bitbuf, 1) == 0)\
185 break;\
186 /* add child nodes */\
187 list[n++] = list[i];\
188 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
189 }
190
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);\
197 }\
198\
199 /* clip to [0..255] */\
200 if (n1 & 0xFF00FF00) {\
201 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
202 n1 += 0x7F007F00;\
203 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
204 n1 &= (n3 & 0x00FF00FF);\
205 }\
206\
207 if (n2 & 0xFF00FF00) {\
208 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
209 n2 += 0x7F007F00;\
210 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
211 n2 &= (n3 & 0x00FF00FF);\
212 }
be8ffec9 213
82dd7d0d
NK
214#define SVQ1_DO_CODEBOOK_INTRA()\
215 for (y=0; y < height; y++) {\
216 for (x=0; x < (width / 4); x++, codebook++) {\
217 n1 = n4;\
218 n2 = n4;\
219 SVQ1_ADD_CODEBOOK()\
220 /* store result */\
221 dst[x] = (n1 << 8) | n2;\
222 }\
223 dst += (pitch / 4);\
224 }
225
226#define SVQ1_DO_CODEBOOK_NONINTRA()\
227 for (y=0; y < height; y++) {\
228 for (x=0; x < (width / 4); x++, codebook++) {\
229 n3 = dst[x];\
230 /* add mean value to vector */\
231 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
232 n2 = (n3 & 0x00FF00FF) + n4;\
233 SVQ1_ADD_CODEBOOK()\
234 /* store result */\
235 dst[x] = (n1 << 8) | n2;\
236 }\
237 dst += (pitch / 4);\
238 }
239
240#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
18f77016 241 codebook = (const uint32_t *) cbook[level];\
82dd7d0d
NK
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);\
246 }\
247 mean -= (stages * 128);\
248 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
be8ffec9 249
59fcece9 250static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
be8ffec9 251 uint32_t bit_cache;
be8ffec9
NK
252 uint8_t *list[63];
253 uint32_t *dst;
18f77016 254 const uint32_t *codebook;
be8ffec9
NK
255 int entries[6];
256 int i, j, m, n;
257 int mean, stages;
18f77016 258 unsigned x, y, width, height, level;
be8ffec9
NK
259 uint32_t n1, n2, n3, n4;
260
261 /* initialize list for breadth first processing of vectors */
262 list[0] = pixels;
263
264 /* recursively process vector */
265 for (i=0, m=1, n=1, level=5; i < n; i++) {
82dd7d0d 266 SVQ1_PROCESS_VECTOR();
be8ffec9
NK
267
268 /* destination address and vector size */
269 dst = (uint32_t *) list[i];
270 width = 1 << ((4 + level) /2);
271 height = 1 << ((3 + level) /2);
272
273 /* get number of stages (-1 skips vector, 0 for mean only) */
59fcece9 274 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
be8ffec9
NK
275
276 if (stages == -1) {
be8ffec9
NK
277 for (y=0; y < height; y++) {
278 memset (&dst[y*(pitch / 4)], 0, width);
279 }
be8ffec9
NK
280 continue; /* skip vector */
281 }
282
283 if ((stages > 0) && (level >= 4)) {
284#ifdef DEBUG_SVQ1
3b64893d 285 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
be8ffec9
NK
286#endif
287 return -1; /* invalid vector */
288 }
289
59fcece9 290 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
be8ffec9 291
82dd7d0d 292 if (stages == 0) {
be8ffec9
NK
293 for (y=0; y < height; y++) {
294 memset (&dst[y*(pitch / 4)], mean, width);
295 }
296 } else {
82dd7d0d
NK
297 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
298 SVQ1_DO_CODEBOOK_INTRA()
299 }
300 }
be8ffec9 301
82dd7d0d
NK
302 return 0;
303}
be8ffec9 304
59fcece9 305static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
82dd7d0d 306 uint32_t bit_cache;
82dd7d0d
NK
307 uint8_t *list[63];
308 uint32_t *dst;
18f77016 309 const uint32_t *codebook;
82dd7d0d
NK
310 int entries[6];
311 int i, j, m, n;
312 int mean, stages;
313 int x, y, width, height, level;
314 uint32_t n1, n2, n3, n4;
be8ffec9 315
82dd7d0d
NK
316 /* initialize list for breadth first processing of vectors */
317 list[0] = pixels;
be8ffec9 318
82dd7d0d
NK
319 /* recursively process vector */
320 for (i=0, m=1, n=1, level=5; i < n; i++) {
321 SVQ1_PROCESS_VECTOR();
be8ffec9 322
82dd7d0d
NK
323 /* destination address and vector size */
324 dst = (uint32_t *) list[i];
325 width = 1 << ((4 + level) /2);
326 height = 1 << ((3 + level) /2);
be8ffec9 327
82dd7d0d 328 /* get number of stages (-1 skips vector, 0 for mean only) */
59fcece9 329 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
82dd7d0d
NK
330
331 if (stages == -1) continue; /* skip vector */
332
333 if ((stages > 0) && (level >= 4)) {
334#ifdef DEBUG_SVQ1
3b64893d 335 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
82dd7d0d
NK
336#endif
337 return -1; /* invalid vector */
be8ffec9 338 }
be8ffec9 339
59fcece9 340 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
82dd7d0d
NK
341
342 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
343 SVQ1_DO_CODEBOOK_NONINTRA()
344 }
be8ffec9
NK
345 return 0;
346}
347
59fcece9
MM
348static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
349 int diff;
be8ffec9
NK
350 int i;
351
352 for (i=0; i < 2; i++) {
353
354 /* get motion code */
5e13a730
MN
355 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
356 if(diff<0)
357 return -1;
358 else if(diff){
359 if(get_bits1(bitbuf)) diff= -diff;
360 }
be8ffec9
NK
361
362 /* add median of motion vector predictors and clip result */
363 if (i == 1)
5e13a730 364 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
be8ffec9 365 else
5e13a730 366 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
be8ffec9
NK
367 }
368
369 return 0;
370}
371
82dd7d0d 372static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
be8ffec9
NK
373 uint8_t *src;
374 uint8_t *dst;
375 int i;
376
377 src = &previous[x + y*pitch];
378 dst = current;
379
380 for (i=0; i < 16; i++) {
381 memcpy (dst, src, 16);
382 src += pitch;
383 dst += pitch;
384 }
385}
386
59fcece9 387static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
be8ffec9
NK
388 uint8_t *current, uint8_t *previous, int pitch,
389 svq1_pmv_t *motion, int x, int y) {
390 uint8_t *src;
391 uint8_t *dst;
392 svq1_pmv_t mv;
393 svq1_pmv_t *pmv[3];
394 int result;
395
396 /* predict and decode motion vector */
397 pmv[0] = &motion[0];
be8ffec9 398 if (y == 0) {
82dd7d0d 399 pmv[1] =
be8ffec9
NK
400 pmv[2] = pmv[0];
401 }
82dd7d0d
NK
402 else {
403 pmv[1] = &motion[(x / 8) + 2];
404 pmv[2] = &motion[(x / 8) + 4];
405 }
be8ffec9 406
82dd7d0d 407 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
be8ffec9
NK
408
409 if (result != 0)
410 return result;
411
82dd7d0d
NK
412 motion[0].x =
413 motion[(x / 8) + 2].x =
be8ffec9 414 motion[(x / 8) + 3].x = mv.x;
82dd7d0d
NK
415 motion[0].y =
416 motion[(x / 8) + 2].y =
be8ffec9 417 motion[(x / 8) + 3].y = mv.y;
b739d676
MN
418
419 if(y + (mv.y >> 1)<0)
420 mv.y= 0;
421 if(x + (mv.x >> 1)<0)
422 mv.x= 0;
423
424#if 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)
3b64893d 428 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
b739d676
MN
429#endif
430
be8ffec9
NK
431 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
432 dst = current;
433
eb4b3dd3 434 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
be8ffec9
NK
435
436 return 0;
437}
438
59fcece9 439static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
be8ffec9
NK
440 uint8_t *current, uint8_t *previous, int pitch,
441 svq1_pmv_t *motion,int x, int y) {
442 uint8_t *src;
443 uint8_t *dst;
444 svq1_pmv_t mv;
445 svq1_pmv_t *pmv[4];
446 int i, result;
447
448 /* predict and decode motion vector (0) */
449 pmv[0] = &motion[0];
be8ffec9 450 if (y == 0) {
82dd7d0d 451 pmv[1] =
be8ffec9
NK
452 pmv[2] = pmv[0];
453 }
82dd7d0d
NK
454 else {
455 pmv[1] = &motion[(x / 8) + 2];
456 pmv[2] = &motion[(x / 8) + 4];
457 }
be8ffec9 458
82dd7d0d 459 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
be8ffec9
NK
460
461 if (result != 0)
462 return result;
463
464 /* predict and decode motion vector (1) */
465 pmv[0] = &mv;
be8ffec9 466 if (y == 0) {
82dd7d0d 467 pmv[1] =
be8ffec9
NK
468 pmv[2] = pmv[0];
469 }
82dd7d0d
NK
470 else {
471 pmv[1] = &motion[(x / 8) + 3];
472 }
473 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
be8ffec9
NK
474
475 if (result != 0)
476 return result;
477
478 /* predict and decode motion vector (2) */
479 pmv[1] = &motion[0];
480 pmv[2] = &motion[(x / 8) + 1];
481
82dd7d0d 482 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
be8ffec9
NK
483
484 if (result != 0)
485 return result;
486
487 /* predict and decode motion vector (3) */
488 pmv[2] = &motion[(x / 8) + 2];
489 pmv[3] = &motion[(x / 8) + 3];
490
82dd7d0d 491 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
be8ffec9
NK
492
493 if (result != 0)
494 return result;
495
496 /* form predictions */
497 for (i=0; i < 4; i++) {
b739d676
MN
498 int mvx= pmv[i]->x + (i&1)*16;
499 int mvy= pmv[i]->y + (i>>1)*16;
500
501 ///XXX /FIXME cliping or padding?
502 if(y + (mvy >> 1)<0)
503 mvy= 0;
504 if(x + (mvx >> 1)<0)
505 mvx= 0;
506
507#if 0
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)
3b64893d 511 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
b739d676
MN
512#endif
513 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
be8ffec9 514 dst = current;
b739d676
MN
515
516 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
be8ffec9
NK
517
518 /* select next block */
519 if (i & 1) {
520 current += 8*(pitch - 1);
be8ffec9
NK
521 } else {
522 current += 8;
be8ffec9
NK
523 }
524 }
525
526 return 0;
527}
528
59fcece9 529static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
be8ffec9
NK
530 uint8_t *current, uint8_t *previous, int pitch,
531 svq1_pmv_t *motion, int x, int y) {
be8ffec9
NK
532 uint32_t block_type;
533 int result = 0;
534
535 /* get block type */
59fcece9 536 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
be8ffec9
NK
537
538 /* reset motion vectors */
539 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
82dd7d0d
NK
540 motion[0].x =
541 motion[0].y =
542 motion[(x / 8) + 2].x =
543 motion[(x / 8) + 2].y =
544 motion[(x / 8) + 3].x =
be8ffec9
NK
545 motion[(x / 8) + 3].y = 0;
546 }
547
548 switch (block_type) {
549 case SVQ1_BLOCK_SKIP:
82dd7d0d 550 svq1_skip_block (current, previous, pitch, x, y);
be8ffec9
NK
551 break;
552
553 case SVQ1_BLOCK_INTER:
eb4b3dd3 554 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
be8ffec9
NK
555
556 if (result != 0)
557 {
558#ifdef DEBUG_SVQ1
3b64893d 559 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
be8ffec9
NK
560#endif
561 break;
562 }
82dd7d0d 563 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
be8ffec9
NK
564 break;
565
566 case SVQ1_BLOCK_INTER_4V:
eb4b3dd3 567 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
be8ffec9
NK
568
569 if (result != 0)
570 {
571#ifdef DEBUG_SVQ1
3b64893d 572 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
be8ffec9
NK
573#endif
574 break;
575 }
82dd7d0d 576 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
be8ffec9
NK
577 break;
578
579 case SVQ1_BLOCK_INTRA:
82dd7d0d 580 result = svq1_decode_block_intra (bitbuf, current, pitch);
be8ffec9
NK
581 break;
582 }
583
584 return result;
585}
586
587/* standard video sizes */
82dd7d0d 588static struct { int width; int height; } svq1_frame_size_table[8] = {
be8ffec9
NK
589 { 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 },
590 { 704, 576 }, { 240, 180 }, { 320, 240 }, { -1, -1 }
591};
592
59fcece9
MM
593static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
594 int i;
595
596 for (i=0; i < length; i++) {
597 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
598 }
599
600 return value;
601}
602
603static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
604 int width, int height, int value) {
605 int x, y;
606
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);
610 }
611
612 pixels += pitch;
613 }
614
615 return value;
616}
617
618static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
619 uint8_t seed;
620 int i;
621
622 out[0] = get_bits (bitbuf, 8);
623
624 seed = string_table[out[0]];
625
2ad5d5a8 626 for (i=1; i <= out[0]; i++) {
59fcece9
MM
627 out[i] = get_bits (bitbuf, 8) ^ seed;
628 seed = string_table[out[i] ^ seed];
629 }
630}
631
632static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
be8ffec9 633 int frame_size_code;
59fcece9 634 int temporal_reference;
be8ffec9 635
59fcece9 636 temporal_reference = get_bits (bitbuf, 8);
be8ffec9
NK
637
638 /* frame type */
760acb18
MN
639 s->pict_type= get_bits (bitbuf, 2)+1;
640 if(s->pict_type==4)
641 return -1;
b739d676 642
760acb18 643 if (s->pict_type == I_TYPE) {
be8ffec9
NK
644
645 /* unknown fields */
646 if (s->f_code == 0x50 || s->f_code == 0x60) {
59fcece9
MM
647 int csum = get_bits (bitbuf, 16);
648
649 csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
650
3b64893d 651// av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
59fcece9 652// (csum == 0) ? "correct" : "incorrect", csum);
be8ffec9
NK
653 }
654
655 if ((s->f_code ^ 0x10) >= 0x50) {
59fcece9
MM
656 char msg[256];
657
658 svq1_parse_string (bitbuf, (char *) msg);
659
9b879566 660 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
be8ffec9
NK
661 }
662
0c938bd1
AB
663 skip_bits (bitbuf, 2);
664 skip_bits (bitbuf, 2);
665 skip_bits1 (bitbuf);
be8ffec9
NK
666
667 /* load frame size */
668 frame_size_code = get_bits (bitbuf, 3);
669
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);
674
675 if (!s->width || !s->height)
676 return -1;
677 } else {
678 /* get width, height from table */
82dd7d0d
NK
679 s->width = svq1_frame_size_table[frame_size_code].width;
680 s->height = svq1_frame_size_table[frame_size_code].height;
be8ffec9
NK
681 }
682 }
683
684 /* unknown fields */
685 if (get_bits (bitbuf, 1) == 1) {
0c938bd1
AB
686 skip_bits1 (bitbuf); /* use packet checksum if (1) */
687 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
be8ffec9
NK
688
689 if (get_bits (bitbuf, 2) != 0)
690 return -1;
691 }
692
693 if (get_bits (bitbuf, 1) == 1) {
0c938bd1
AB
694 skip_bits1 (bitbuf);
695 skip_bits (bitbuf, 4);
696 skip_bits1 (bitbuf);
697 skip_bits (bitbuf, 2);
be8ffec9
NK
698
699 while (get_bits (bitbuf, 1) == 1) {
0c938bd1 700 skip_bits (bitbuf, 8);
be8ffec9
NK
701 }
702 }
703
704 return 0;
705}
706
707static int svq1_decode_frame(AVCodecContext *avctx,
708 void *data, int *data_size,
0c1a9eda 709 uint8_t *buf, int buf_size)
be8ffec9
NK
710{
711 MpegEncContext *s=avctx->priv_data;
712 uint8_t *current, *previous;
713 int result, i, x, y, width, height;
492cd3a9 714 AVFrame *pict = data;
be8ffec9 715
270f8784
MN
716 if(buf==NULL && buf_size==0){
717 return 0;
718 }
719
be8ffec9 720 /* initialize bit buffer */
68f593b4 721 init_get_bits(&s->gb,buf,buf_size*8);
be8ffec9
NK
722
723 /* decode frame header */
724 s->f_code = get_bits (&s->gb, 22);
725
726 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
727 return -1;
728
729 /* swap some header bytes (why?) */
730 if (s->f_code != 0x20) {
731 uint32_t *src = (uint32_t *) (buf + 4);
732
733 for (i=0; i < 4; i++) {
734 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
735 }
736 }
737
82dd7d0d 738 result = svq1_decode_frame_header (&s->gb, s);
be8ffec9
NK
739
740 if (result != 0)
741 {
742#ifdef DEBUG_SVQ1
3b64893d 743 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
be8ffec9
NK
744#endif
745 return result;
746 }
bc6d7776 747
e5ab4fdd 748 //FIXME this avoids some confusion for "B frames" without 2 references
3b64893d 749 //this should be removed after libavcodec can handle more flexible picture types & ordering
b536d0aa 750 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
e5ab4fdd 751
bc6d7776 752 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
be8ffec9 753
1e491e29
MN
754 if(MPV_frame_start(s, avctx) < 0)
755 return -1;
756
be8ffec9
NK
757 /* decode y, u and v components */
758 for (i=0; i < 3; i++) {
760acb18 759 int linesize;
be8ffec9 760 if (i == 0) {
82dd7d0d
NK
761 width = (s->width+15)&~15;
762 height = (s->height+15)&~15;
760acb18 763 linesize= s->linesize;
be8ffec9 764 } else {
22b13d5b 765 if(s->flags&CODEC_FLAG_GRAY) break;
82dd7d0d
NK
766 width = (s->width/4+15)&~15;
767 height = (s->height/4+15)&~15;
760acb18 768 linesize= s->uvlinesize;
be8ffec9
NK
769 }
770
1e491e29 771 current = s->current_picture.data[i];
be8ffec9 772
760acb18 773 if(s->pict_type==B_TYPE){
1e491e29 774 previous = s->next_picture.data[i];
760acb18 775 }else{
1e491e29 776 previous = s->last_picture.data[i];
760acb18
MN
777 }
778
779 if (s->pict_type == I_TYPE) {
be8ffec9
NK
780 /* keyframe */
781 for (y=0; y < height; y+=16) {
782 for (x=0; x < width; x+=16) {
760acb18 783 result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
be8ffec9
NK
784 if (result != 0)
785 {
3b64893d
MM
786//#ifdef DEBUG_SVQ1
787 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
788//#endif
be8ffec9
NK
789 return result;
790 }
791 }
760acb18 792 current += 16*linesize;
be8ffec9
NK
793 }
794 } else {
760acb18 795 svq1_pmv_t pmv[width/8+3];
be8ffec9 796 /* delta frame */
760acb18 797 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
be8ffec9
NK
798
799 for (y=0; y < height; y+=16) {
800 for (x=0; x < width; x+=16) {
eb4b3dd3
ZK
801 result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
802 linesize, pmv, x, y);
be8ffec9
NK
803 if (result != 0)
804 {
805#ifdef DEBUG_SVQ1
3b64893d 806 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
be8ffec9
NK
807#endif
808 return result;
809 }
810 }
811
760acb18
MN
812 pmv[0].x =
813 pmv[0].y = 0;
be8ffec9 814
760acb18 815 current += 16*linesize;
be8ffec9
NK
816 }
817 }
be8ffec9 818 }
1e491e29 819
492cd3a9 820 *pict = *(AVFrame*)&s->current_picture;
760acb18 821
1e491e29
MN
822
823 MPV_frame_end(s);
824
492cd3a9 825 *data_size=sizeof(AVFrame);
bc6d7776 826 return buf_size;
be8ffec9
NK
827}
828
829static int svq1_decode_init(AVCodecContext *avctx)
830{
831 MpegEncContext *s = avctx->priv_data;
59fcece9 832 int i;
ce23c668 833
3edcacde
MN
834 MPV_decode_defaults(s);
835
be8ffec9
NK
836 s->avctx = avctx;
837 s->width = (avctx->width+3)&~3;
838 s->height = (avctx->height+3)&~3;
839 s->codec_id= avctx->codec->id;
be8ffec9 840 avctx->pix_fmt = PIX_FMT_YUV410P;
4e00e76b 841 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
3b64893d 842 s->flags= avctx->flags;
760acb18 843 if (MPV_common_init(s) < 0) return -1;
59fcece9
MM
844
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);
848
5e13a730
MN
849 init_vlc(&svq1_motion_component, 7, 33,
850 &mvtab[0][1], 2, 1,
851 &mvtab[0][0], 2, 1);
59fcece9
MM
852
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);
860 }
861
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);
865
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);
869
be8ffec9
NK
870 return 0;
871}
872
873static int svq1_decode_end(AVCodecContext *avctx)
874{
875 MpegEncContext *s = avctx->priv_data;
876
877 MPV_common_end(s);
be8ffec9
NK
878 return 0;
879}
880
3b64893d
MM
881static void svq1_write_header(SVQ1Context *s, int frame_type)
882{
883 /* frame code */
884 put_bits(&s->pb, 22, 0x20);
885
886 /* temporal reference (sure hope this is a "don't care") */
887 put_bits(&s->pb, 8, 0x00);
888
889 /* frame type */
890 put_bits(&s->pb, 2, frame_type - 1);
891
892 if (frame_type == I_TYPE) {
893
894 /* no checksum since frame code is 0x20 */
895
896 /* no embedded string either */
897
898 /* output 5 unknown bits (2 + 2 + 1) */
899 put_bits(&s->pb, 5, 0);
900
901 /* forget about matching up resolutions, just use the free-form
902 * resolution code (7) for now */
903 put_bits(&s->pb, 3, 7);
904 put_bits(&s->pb, 12, s->frame_width);
905 put_bits(&s->pb, 12, s->frame_height);
906
907 }
908
909 /* no checksum or extra data (next 2 bits get 0) */
910 put_bits(&s->pb, 2, 0);
911}
912
3b64893d
MM
913
914#define QUALITY_THRESHOLD 100
915#define THRESHOLD_MULTIPLIER 0.6
916
69de449a
MN
917#if defined(HAVE_ALTIVEC)
918#undef vector
919#endif
3b64893d 920
ec6d8af5 921static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){
fa2ae822
MN
922 int count, y, x, i, j, split, best_mean, best_score, best_count;
923 int best_vector[6];
924 int block_sum[7]= {0, 0, 0, 0, 0, 0};
925 int w= 2<<((level+2)>>1);
926 int h= 2<<((level+1)>>1);
927 int size=w*h;
928 int16_t block[7][256];
0d8e09f8
MN
929 const int8_t *codebook_sum, *codebook;
930 const uint16_t (*mean_vlc)[2];
931 const uint8_t (*multistage_vlc)[2];
932
ec6d8af5
MN
933 best_score=0;
934 //FIXME optimize, this doenst need to be done multiple times
0d8e09f8
MN
935 if(intra){
936 codebook_sum= svq1_intra_codebook_sum[level];
937 codebook= svq1_intra_codebooks[level];
938 mean_vlc= svq1_intra_mean_vlc;
939 multistage_vlc= svq1_intra_multistage_vlc[level];
ec6d8af5
MN
940 for(y=0; y<h; y++){
941 for(x=0; x<w; x++){
942 int v= src[x + y*stride];
943 block[0][x + w*y]= v;
944 best_score += v*v;
945 block_sum[0] += v;
946 }
947 }
0d8e09f8
MN
948 }else{
949 codebook_sum= svq1_inter_codebook_sum[level];
950 codebook= svq1_inter_codebooks[level];
ec6d8af5 951 mean_vlc= svq1_inter_mean_vlc + 256;
0d8e09f8 952 multistage_vlc= svq1_inter_multistage_vlc[level];
ec6d8af5
MN
953 for(y=0; y<h; y++){
954 for(x=0; x<w; x++){
955 int v= src[x + y*stride] - ref[x + y*stride];
956 block[0][x + w*y]= v;
957 best_score += v*v;
958 block_sum[0] += v;
959 }
fa2ae822
MN
960 }
961 }
962
963 best_count=0;
964 best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
965 best_mean= (block_sum[0] + (size>>1)) >> (level+3);
966
967 if(level<4){
968 for(count=1; count<7; count++){
969 int best_vector_score= INT_MAX;
ec6d8af5 970 int best_vector_sum=-999, best_vector_mean=-999;
fa2ae822 971 const int stage= count-1;
0d8e09f8 972 const int8_t *vector;
fa2ae822
MN
973
974 for(i=0; i<16; i++){
0d8e09f8 975 int sum= codebook_sum[stage*16 + i];
fa2ae822
MN
976 int sqr=0;
977 int diff, mean, score;
978
0d8e09f8 979 vector = codebook + stage*size*16 + i*size;
fa2ae822
MN
980
981 for(j=0; j<size; j++){
982 int v= vector[j];
fa2ae822
MN
983 sqr += (v - block[stage][j])*(v - block[stage][j]);
984 }
985 diff= block_sum[stage] - sum;
986 mean= (diff + (size>>1)) >> (level+3);
ec6d8af5
MN
987 assert(mean >-300 && mean<300);
988 if(intra) mean= clip(mean, 0, 255);
989 else mean= clip(mean, -256, 255);
fa2ae822
MN
990 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
991 if(score < best_vector_score){
992 best_vector_score= score;
993 best_vector[stage]= i;
994 best_vector_sum= sum;
995 best_vector_mean= mean;
996 }
997 }
ec6d8af5 998 assert(best_vector_mean != -999);
0d8e09f8 999 vector= codebook + stage*size*16 + best_vector[stage]*size;
fa2ae822
MN
1000 for(j=0; j<size; j++){
1001 block[stage+1][j] = block[stage][j] - vector[j];
1002 }
1003 block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1004 best_vector_score +=
1005 lambda*(+ 1 + 4*count
0d8e09f8
MN
1006 + multistage_vlc[1+count][1]
1007 + mean_vlc[best_vector_mean][1]);
fa2ae822
MN
1008
1009 if(best_vector_score < best_score){
1010 best_score= best_vector_score;
1011 best_count= count;
1012 best_mean= best_vector_mean;
1013 }
1014 }
1015 }
1016
1017 split=0;
1018 if(best_score > threshold && level){
1019 int score=0;
1020 int offset= (level&1) ? stride*h/2 : w/2;
1021 PutBitContext backup[6];
1022
1023 for(i=level-1; i>=0; i--){
1024 backup[i]= s->reorder_pb[i];
1025 }
ec6d8af5
MN
1026 score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
1027 score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
fa2ae822
MN
1028 score += lambda;
1029
1030 if(score < best_score){
1031 best_score= score;
1032 split=1;
1033 }else{
1034 for(i=level-1; i>=0; i--){
1035 s->reorder_pb[i]= backup[i];
1036 }
1037 }
1038 }
1039 if (level > 0)
1040 put_bits(&s->reorder_pb[level], 1, split);
1041
1042 if(!split){
ec6d8af5
MN
1043 assert((best_mean >= 0 && best_mean<256) || !intra);
1044 assert(best_mean >= -256 && best_mean<256);
fa2ae822
MN
1045 assert(best_count >=0 && best_count<7);
1046 assert(level<4 || best_count==0);
1047
1048 /* output the encoding */
1049 put_bits(&s->reorder_pb[level],
0d8e09f8
MN
1050 multistage_vlc[1 + best_count][1],
1051 multistage_vlc[1 + best_count][0]);
1052 put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1053 mean_vlc[best_mean][0]);
fa2ae822
MN
1054
1055 for (i = 0; i < best_count; i++){
1056 assert(best_vector[i]>=0 && best_vector[i]<16);
1057 put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1058 }
ec6d8af5
MN
1059
1060 for(y=0; y<h; y++){
1061 for(x=0; x<w; x++){
1062 decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1063 }
1064 }
fa2ae822
MN
1065 }
1066
1067 return best_score;
1068}
1069
975af7a9
MM
1070#ifdef CONFIG_ENCODERS
1071
5e13a730 1072static void svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
ec6d8af5 1073 int width, int height, int src_stride, int stride)
3b64893d 1074{
3b64893d 1075 int x, y;
cc77b943 1076 int i;
3b64893d 1077 int block_width, block_height;
3b64893d
MM
1078 int level;
1079 int threshold[6];
ec6d8af5 1080 const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
3b64893d 1081
3b64893d
MM
1082 /* figure out the acceptable level thresholds in advance */
1083 threshold[5] = QUALITY_THRESHOLD;
1084 for (level = 4; level >= 0; level--)
1085 threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1086
1087 block_width = (width + 15) / 16;
1088 block_height = (height + 15) / 16;
1089
5e13a730
MN
1090 if(s->picture.pict_type == P_TYPE){
1091 s->m.avctx= s->avctx;
1092 s->m.current_picture_ptr= &s->m.current_picture;
1093 s->m.last_picture_ptr = &s->m.last_picture;
1094 s->m.last_picture.data[0]= ref_plane;
1095 s->m.linesize=
1096 s->m.last_picture.linesize[0]=
1097 s->m.new_picture.linesize[0]=
1098 s->m.current_picture.linesize[0]= stride;
1099 s->m.width= width;
1100 s->m.height= height;
1101 s->m.mb_width= block_width;
1102 s->m.mb_height= block_height;
1103 s->m.mb_stride= s->m.mb_width+1;
1104 s->m.b8_stride= 2*s->m.mb_width+1;
1105 s->m.f_code=1;
1106 s->m.pict_type= s->picture.pict_type;
1107 s->m.qscale= s->picture.quality/FF_QP2LAMBDA;
1108 s->m.me_method= s->avctx->me_method;
1109
1110 if(!s->motion_val8[plane]){
7a046364
MN
1111 s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1112 s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
5e13a730 1113 }
7a046364 1114
5e13a730
MN
1115 s->m.mb_type= s->mb_type;
1116
1117 //dummies, to avoid segfaults
cc77b943
MN
1118 s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
1119 s->m.current_picture.mb_var= (uint16_t*)s->dummy;
1120 s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
5e13a730
MN
1121 s->m.current_picture.mb_type= s->dummy;
1122
7a046364
MN
1123 s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1124 s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
5e13a730
MN
1125 s->m.dsp= s->dsp; //move
1126 ff_init_me(&s->m);
1127
1128 s->m.me.dia_size= s->avctx->dia_size;
1129 s->m.first_slice_line=1;
1130 for (y = 0; y < block_height; y++) {
1131 uint8_t src[stride*16];
1132
1133 s->m.new_picture.data[0]= src - y*16*stride; //ugly
1134 s->m.mb_y= y;
1135
1136 for(i=0; i<16 && i + 16*y<height; i++){
1137 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1138 for(x=width; x<16*block_width; x++)
1139 src[i*stride+x]= src[i*stride+x-1];
1140 }
1141 for(; i<16 && i + 16*y<16*block_height; i++)
1142 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1143
1144 for (x = 0; x < block_width; x++) {
1145 s->m.mb_x= x;
1146 ff_init_block_index(&s->m);
1147 ff_update_block_index(&s->m);
1148
1149 ff_estimate_p_frame_motion(&s->m, x, y);
1150 }
1151 s->m.first_slice_line=0;
1152 }
1153
1154 ff_fix_long_p_mvs(&s->m);
1155 ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1156 }
1157
1158 s->m.first_slice_line=1;
3b64893d 1159 for (y = 0; y < block_height; y++) {
ec6d8af5
MN
1160 uint8_t src[stride*16];
1161
1162 for(i=0; i<16 && i + 16*y<height; i++){
1163 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1164 for(x=width; x<16*block_width; x++)
1165 src[i*stride+x]= src[i*stride+x-1];
1166 }
1167 for(; i<16 && i + 16*y<16*block_height; i++)
1168 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
3b64893d 1169
5e13a730 1170 s->m.mb_y= y;
3b64893d 1171 for (x = 0; x < block_width; x++) {
5e13a730
MN
1172 uint8_t reorder_buffer[3][6][7*32];
1173 int count[3][6];
ec6d8af5
MN
1174 int offset = y * 16 * stride + x * 16;
1175 uint8_t *decoded= decoded_plane + offset;
1176 uint8_t *ref= ref_plane + offset;
5e13a730 1177 int score[4]={0,0,0,0}, best;
ec6d8af5 1178 uint8_t temp[16*stride];
3b64893d 1179
5e13a730
MN
1180 s->m.mb_x= x;
1181 ff_init_block_index(&s->m);
1182 ff_update_block_index(&s->m);
fa2ae822 1183
5e13a730
MN
1184 if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1185 for(i=0; i<6; i++){
1186 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1187 }
1188 if(s->picture.pict_type == P_TYPE){
1189 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1190 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1191 score[0]= vlc[1]*lambda;
1192 }
1193 score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1194 for(i=0; i<6; i++){
1195 count[0][i]= put_bits_count(&s->reorder_pb[i]);
1196 flush_put_bits(&s->reorder_pb[i]);
1197 }
1198 }else
1199 score[0]= INT_MAX;
1200
1201 best=0;
1202
ec6d8af5
MN
1203 if(s->picture.pict_type == P_TYPE){
1204 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
5e13a730
MN
1205 int mx, my, pred_x, pred_y, dxy;
1206 int16_t *motion_ptr;
1207
1208 motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1209 if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1210 for(i=0; i<6; i++)
1211 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1212
ec6d8af5 1213 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
5e13a730
MN
1214
1215 s->m.pb= s->reorder_pb[5];
1216 mx= motion_ptr[0];
1217 my= motion_ptr[1];
1218 assert(mx>=-32 && mx<=31);
1219 assert(my>=-32 && my<=31);
1220 assert(pred_x>=-32 && pred_x<=31);
1221 assert(pred_y>=-32 && pred_y<=31);
1222 ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1223 ff_h263_encode_motion(&s->m, my - pred_y, 1);
1224 s->reorder_pb[5]= s->m.pb;
1225 score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1226
1227 dxy= (mx&1) + 2*(my&1);
1228
1229 s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1230
1231 score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1232 best= score[1] <= score[0];
3178a865
MN
1233
1234 vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1235 score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1236 score[2]+= vlc[1]*lambda;
1237 if(score[2] < score[best] && mx==0 && my==0){
1238 best=2;
1239 s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1240 for(i=0; i<6; i++){
1241 count[2][i]=0;
1242 }
1243 put_bits(&s->pb, vlc[1], vlc[0]);
1244 }
ec6d8af5 1245 }
3178a865 1246
ec6d8af5
MN
1247 if(best==1){
1248 for(i=0; i<6; i++){
1249 count[1][i]= put_bits_count(&s->reorder_pb[i]);
1250 flush_put_bits(&s->reorder_pb[i]);
1251 }
5e13a730
MN
1252 }else{
1253 motion_ptr[0 ] = motion_ptr[1 ]=
1254 motion_ptr[2 ] = motion_ptr[3 ]=
1255 motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1256 motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
ec6d8af5 1257 }
5e13a730 1258 }
ec6d8af5
MN
1259
1260 s->rd_total += score[best];
1261
1262 for(i=5; i>=0; i--){
1263 ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1264 }
1265 if(best==0){
1266 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
fa2ae822 1267 }
3b64893d 1268 }
5e13a730 1269 s->m.first_slice_line=0;
3b64893d
MM
1270 }
1271}
1272
3b64893d
MM
1273static int svq1_encode_init(AVCodecContext *avctx)
1274{
1275 SVQ1Context * const s = avctx->priv_data;
3b64893d
MM
1276
1277 dsputil_init(&s->dsp, avctx);
1278 avctx->coded_frame= (AVFrame*)&s->picture;
1279
1280 s->frame_width = avctx->width;
1281 s->frame_height = avctx->height;
1282
1283 s->y_block_width = (s->frame_width + 15) / 16;
1284 s->y_block_height = (s->frame_height + 15) / 16;
1285
1286 s->c_block_width = (s->frame_width / 4 + 15) / 16;
1287 s->c_block_height = (s->frame_height / 4 + 15) / 16;
1288
5e13a730
MN
1289 s->avctx= avctx;
1290 s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
1291 s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1292 s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1293 s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1294 s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1295 h263_encode_init(&s->m); //mv_penalty
1296
3b64893d
MM
1297 return 0;
1298}
1299
1300static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
1301 int buf_size, void *data)
1302{
1303 SVQ1Context * const s = avctx->priv_data;
1304 AVFrame *pict = data;
1305 AVFrame * const p= (AVFrame*)&s->picture;
ec6d8af5
MN
1306 AVFrame temp;
1307 int i;
3b64893d 1308
ec6d8af5
MN
1309 if(avctx->pix_fmt != PIX_FMT_YUV410P){
1310 av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1311 return -1;
1312 }
1313
1314 if(!s->current_picture.data[0]){
1315 avctx->get_buffer(avctx, &s->current_picture);
1316 avctx->get_buffer(avctx, &s->last_picture);
1317 }
1318
1319 temp= s->current_picture;
1320 s->current_picture= s->last_picture;
1321 s->last_picture= temp;
1322
3b64893d
MM
1323 init_put_bits(&s->pb, buf, buf_size);
1324
1325 *p = *pict;
ec6d8af5 1326 p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
0d8e09f8 1327 p->key_frame = p->pict_type == I_TYPE;
3b64893d
MM
1328
1329 svq1_write_header(s, p->pict_type);
ec6d8af5 1330 for(i=0; i<3; i++){
5e13a730 1331 svq1_encode_plane(s, i,
ec6d8af5
MN
1332 s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1333 s->frame_width / (i?4:1), s->frame_height / (i?4:1),
1334 s->picture.linesize[i], s->current_picture.linesize[i]);
3b64893d
MM
1335 }
1336
1337// align_put_bits(&s->pb);
1338 while(put_bits_count(&s->pb) & 31)
1339 put_bits(&s->pb, 1, 0);
14aa9da3
MN
1340
1341 flush_put_bits(&s->pb);
3b64893d
MM
1342
1343 return (put_bits_count(&s->pb) / 8);
1344}
1345
1346static int svq1_encode_end(AVCodecContext *avctx)
1347{
1348 SVQ1Context * const s = avctx->priv_data;
5e13a730 1349 int i;
3b64893d 1350
bab97b2f
MN
1351 av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1352
5e13a730
MN
1353 av_freep(&s->m.me.scratchpad);
1354 av_freep(&s->m.me.map);
1355 av_freep(&s->m.me.score_map);
1356 av_freep(&s->mb_type);
1357 av_freep(&s->dummy);
1358
1359 for(i=0; i<3; i++){
1360 av_freep(&s->motion_val8[i]);
1361 av_freep(&s->motion_val16[i]);
1362 }
3b64893d
MM
1363
1364 return 0;
1365}
1366
975af7a9
MM
1367#endif //CONFIG_ENCODERS
1368
be8ffec9
NK
1369AVCodec svq1_decoder = {
1370 "svq1",
1371 CODEC_TYPE_VIDEO,
1372 CODEC_ID_SVQ1,
1373 sizeof(MpegEncContext),
1374 svq1_decode_init,
1375 NULL,
1376 svq1_decode_end,
760acb18
MN
1377 svq1_decode_frame,
1378 CODEC_CAP_DR1,
7a06ff14 1379 .flush= ff_mpeg_flush,
fcee0164 1380 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
be8ffec9 1381};
3b64893d
MM
1382
1383#ifdef CONFIG_ENCODERS
1384
1385AVCodec svq1_encoder = {
1386 "svq1",
1387 CODEC_TYPE_VIDEO,
1388 CODEC_ID_SVQ1,
1389 sizeof(SVQ1Context),
1390 svq1_encode_init,
1391 svq1_encode_frame,
1392 svq1_encode_end,
fcee0164 1393 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
3b64893d
MM
1394};
1395
1396#endif //CONFIG_ENCODERS