Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1.c @ 5509bffa

History | View | Annotate | Download (43.1 KB)

1
/*
2
 *
3
 * Copyright (C) 2002 the xine project
4
 * Copyright (C) 2002 the ffmpeg project
5
 *
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 *
20
 * (SVQ1 Decoder)
21
 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
22
 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
23
 *
24
 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
25
 */
26

    
27
/**
28
 * @file svq1.c
29
 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
30
 * For more information of the SVQ1 algorithm, visit:
31
 *   http://www.pcisys.net/~melanson/codecs/
32
 */
33

    
34

    
35
//#define DEBUG_SVQ1
36
#include <stdio.h>
37
#include <stdlib.h>
38
#include <string.h>
39
#include <unistd.h>
40
#include <limits.h>
41

    
42
#include "common.h"
43
#include "avcodec.h"
44
#include "dsputil.h"
45
#include "mpegvideo.h"
46
#include "bswap.h"
47

    
48
#undef NDEBUG
49
#include <assert.h>
50

    
51
extern const uint8_t mvtab[33][2];
52

    
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;
59

    
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

    
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;
68
    DSPContext dsp;
69
    AVFrame picture;
70
    AVFrame current_picture;
71
    AVFrame last_picture;
72
    PutBitContext pb;
73
    GetBitContext gb;
74

    
75
    PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
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;
87

    
88
    uint16_t *mb_type;
89
    uint32_t *dummy;
90
    int16_t (*motion_val8[3])[2];
91
    int16_t (*motion_val16[3])[2];
92

    
93
    int64_t rd_total;
94
} SVQ1Context;
95

    
96
/* motion vector (prediction) */
97
typedef struct svq1_pmv_s {
98
  int           x;
99
  int           y;
100
} svq1_pmv_t;
101

    
102
#include "svq1_cb.h"
103
#include "svq1_vlc.h"
104

    
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
138
};
139

    
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
173
};
174

    
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
          }
213

    
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)\
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);\
246
      }\
247
      mean -= (stages * 128);\
248
      n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
249

    
250
static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
251
  uint32_t    bit_cache;
252
  uint8_t    *list[63];
253
  uint32_t   *dst;
254
  const uint32_t *codebook;
255
  int         entries[6];
256
  int         i, j, m, n;
257
  int         mean, stages;
258
  unsigned    x, y, width, height, level;
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++) {
266
    SVQ1_PROCESS_VECTOR();
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) */
274
    stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
275

    
276
    if (stages == -1) {
277
        for (y=0; y < height; y++) {
278
          memset (&dst[y*(pitch / 4)], 0, width);
279
        }
280
      continue;                 /* skip vector */
281
    }
282

    
283
    if ((stages > 0) && (level >= 4)) {
284
#ifdef DEBUG_SVQ1
285
    av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
286
#endif
287
      return -1;        /* invalid vector */
288
    }
289

    
290
    mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
291

    
292
    if (stages == 0) {
293
      for (y=0; y < height; y++) {
294
        memset (&dst[y*(pitch / 4)], mean, width);
295
      }
296
    } else {
297
      SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
298
      SVQ1_DO_CODEBOOK_INTRA()
299
    }
300
  }
301

    
302
  return 0;
303
}
304

    
305
static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
306
  uint32_t    bit_cache;
307
  uint8_t    *list[63];
308
  uint32_t   *dst;
309
  const uint32_t *codebook;
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;
315

    
316
  /* initialize list for breadth first processing of vectors */
317
  list[0] = pixels;
318

    
319
  /* recursively process vector */
320
  for (i=0, m=1, n=1, level=5; i < n; i++) {
321
    SVQ1_PROCESS_VECTOR();
322

    
323
    /* destination address and vector size */
324
    dst = (uint32_t *) list[i];
325
    width = 1 << ((4 + level) /2);
326
    height = 1 << ((3 + level) /2);
327

    
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;
330

    
331
    if (stages == -1) continue; /* skip vector */
332

    
333
    if ((stages > 0) && (level >= 4)) {
334
#ifdef DEBUG_SVQ1
335
    av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
336
#endif
337
      return -1;        /* invalid vector */
338
    }
339

    
340
    mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
341

    
342
    SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
343
    SVQ1_DO_CODEBOOK_NONINTRA()
344
  }
345
  return 0;
346
}
347

    
348
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
349
  int        diff;
350
  int        i;
351

    
352
  for (i=0; i < 2; i++) {
353

    
354
    /* get motion code */
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
    }
361

    
362
    /* add median of motion vector predictors and clip result */
363
    if (i == 1)
364
      mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
365
    else
366
      mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
367
  }
368

    
369
  return 0;
370
}
371

    
372
static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
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

    
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) {
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];
398
  if (y == 0) {
399
    pmv[1] =
400
    pmv[2] = pmv[0];
401
  }
402
  else {
403
    pmv[1] = &motion[(x / 8) + 2];
404
    pmv[2] = &motion[(x / 8) + 4];
405
  }
406

    
407
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
408

    
409
  if (result != 0)
410
    return result;
411

    
412
  motion[0].x                =
413
  motion[(x / 8) + 2].x      =
414
  motion[(x / 8) + 3].x      = mv.x;
415
  motion[0].y                =
416
  motion[(x / 8) + 2].y      =
417
  motion[(x / 8) + 3].y      = mv.y;
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)
428
      av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
429
#endif
430

    
431
  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
432
  dst = current;
433

    
434
  s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
435

    
436
  return 0;
437
}
438

    
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) {
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];
450
  if (y == 0) {
451
    pmv[1] =
452
    pmv[2] = pmv[0];
453
  }
454
  else {
455
    pmv[1] = &motion[(x / 8) + 2];
456
    pmv[2] = &motion[(x / 8) + 4];
457
  }
458

    
459
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
460

    
461
  if (result != 0)
462
    return result;
463

    
464
  /* predict and decode motion vector (1) */
465
  pmv[0] = &mv;
466
  if (y == 0) {
467
    pmv[1] =
468
    pmv[2] = pmv[0];
469
  }
470
  else {
471
    pmv[1] = &motion[(x / 8) + 3];
472
  }
473
  result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
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

    
482
  result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
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

    
491
  result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
492

    
493
  if (result != 0)
494
    return result;
495

    
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;
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)
511
      av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
512
#endif
513
    src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
514
    dst = current;
515

    
516
    s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
517

    
518
    /* select next block */
519
    if (i & 1) {
520
      current  += 8*(pitch - 1);
521
    } else {
522
      current  += 8;
523
    }
524
  }
525

    
526
  return 0;
527
}
528

    
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) {
532
  uint32_t block_type;
533
  int      result = 0;
534

    
535
  /* get block type */
536
  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
537

    
538
  /* reset motion vectors */
539
  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
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 =
545
    motion[(x / 8) + 3].y = 0;
546
  }
547

    
548
  switch (block_type) {
549
  case SVQ1_BLOCK_SKIP:
550
    svq1_skip_block (current, previous, pitch, x, y);
551
    break;
552

    
553
  case SVQ1_BLOCK_INTER:
554
    result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
555

    
556
    if (result != 0)
557
    {
558
#ifdef DEBUG_SVQ1
559
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
560
#endif
561
      break;
562
    }
563
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
564
    break;
565

    
566
  case SVQ1_BLOCK_INTER_4V:
567
    result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
568

    
569
    if (result != 0)
570
    {
571
#ifdef DEBUG_SVQ1
572
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
573
#endif
574
      break;
575
    }
576
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
577
    break;
578

    
579
  case SVQ1_BLOCK_INTRA:
580
    result = svq1_decode_block_intra (bitbuf, current, pitch);
581
    break;
582
  }
583

    
584
  return result;
585
}
586

    
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 }
591
};
592

    
593
static 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

    
603
#if 0 /* unused, remove? */
604
static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
605
                                         int width, int height, int value) {
606
  int x, y;
607

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);
611
    }
612

613
    pixels += pitch;
614
  }
615

616
  return value;
617
}
618
#endif
619

    
620
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
621
  uint8_t seed;
622
  int     i;
623

    
624
  out[0] = get_bits (bitbuf, 8);
625

    
626
  seed = string_table[out[0]];
627

    
628
  for (i=1; i <= out[0]; i++) {
629
    out[i] = get_bits (bitbuf, 8) ^ seed;
630
    seed   = string_table[out[i] ^ seed];
631
  }
632
}
633

    
634
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
635
  int frame_size_code;
636
  int temporal_reference;
637

    
638
  temporal_reference = get_bits (bitbuf, 8);
639

    
640
  /* frame type */
641
  s->pict_type= get_bits (bitbuf, 2)+1;
642
  if(s->pict_type==4)
643
      return -1;
644

    
645
  if (s->pict_type == I_TYPE) {
646

    
647
    /* unknown fields */
648
    if (s->f_code == 0x50 || s->f_code == 0x60) {
649
      int csum = get_bits (bitbuf, 16);
650

    
651
      csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
652

    
653
//      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
654
//              (csum == 0) ? "correct" : "incorrect", csum);
655
    }
656

    
657
    if ((s->f_code ^ 0x10) >= 0x50) {
658
      char msg[256];
659

    
660
      svq1_parse_string (bitbuf, (char *) msg);
661

    
662
      av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
663
    }
664

    
665
    skip_bits (bitbuf, 2);
666
    skip_bits (bitbuf, 2);
667
    skip_bits1 (bitbuf);
668

    
669
    /* load frame size */
670
    frame_size_code = get_bits (bitbuf, 3);
671

    
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);
676

    
677
      if (!s->width || !s->height)
678
        return -1;
679
    } else {
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;
683
    }
684
  }
685

    
686
  /* unknown fields */
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) */
690

    
691
    if (get_bits (bitbuf, 2) != 0)
692
      return -1;
693
  }
694

    
695
  if (get_bits (bitbuf, 1) == 1) {
696
    skip_bits1 (bitbuf);
697
    skip_bits (bitbuf, 4);
698
    skip_bits1 (bitbuf);
699
    skip_bits (bitbuf, 2);
700

    
701
    while (get_bits (bitbuf, 1) == 1) {
702
      skip_bits (bitbuf, 8);
703
    }
704
  }
705

    
706
  return 0;
707
}
708

    
709
static int svq1_decode_frame(AVCodecContext *avctx,
710
                             void *data, int *data_size,
711
                             uint8_t *buf, int buf_size)
712
{
713
  MpegEncContext *s=avctx->priv_data;
714
  uint8_t        *current, *previous;
715
  int             result, i, x, y, width, height;
716
  AVFrame *pict = data;
717

    
718
  /* initialize bit buffer */
719
  init_get_bits(&s->gb,buf,buf_size*8);
720

    
721
  /* decode frame header */
722
  s->f_code = get_bits (&s->gb, 22);
723

    
724
  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
725
    return -1;
726

    
727
  /* swap some header bytes (why?) */
728
  if (s->f_code != 0x20) {
729
    uint32_t *src = (uint32_t *) (buf + 4);
730

    
731
    for (i=0; i < 4; i++) {
732
      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
733
    }
734
  }
735

    
736
  result = svq1_decode_frame_header (&s->gb, s);
737

    
738
  if (result != 0)
739
  {
740
#ifdef DEBUG_SVQ1
741
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
742
#endif
743
    return result;
744
  }
745

    
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;
749

    
750
  if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
751
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
752
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
753
     || avctx->skip_frame >= AVDISCARD_ALL)
754
      return buf_size;
755

    
756
  if(MPV_frame_start(s, avctx) < 0)
757
      return -1;
758

    
759
  /* decode y, u and v components */
760
  for (i=0; i < 3; i++) {
761
    int linesize;
762
    if (i == 0) {
763
      width  = (s->width+15)&~15;
764
      height = (s->height+15)&~15;
765
      linesize= s->linesize;
766
    } else {
767
      if(s->flags&CODEC_FLAG_GRAY) break;
768
      width  = (s->width/4+15)&~15;
769
      height = (s->height/4+15)&~15;
770
      linesize= s->uvlinesize;
771
    }
772

    
773
    current  = s->current_picture.data[i];
774

    
775
    if(s->pict_type==B_TYPE){
776
        previous = s->next_picture.data[i];
777
    }else{
778
        previous = s->last_picture.data[i];
779
    }
780

    
781
    if (s->pict_type == I_TYPE) {
782
      /* keyframe */
783
      for (y=0; y < height; y+=16) {
784
        for (x=0; x < width; x+=16) {
785
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
786
          if (result != 0)
787
          {
788
//#ifdef DEBUG_SVQ1
789
            av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
790
//#endif
791
            return result;
792
          }
793
        }
794
        current += 16*linesize;
795
      }
796
    } else {
797
      svq1_pmv_t pmv[width/8+3];
798
      /* delta frame */
799
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
800

    
801
      for (y=0; y < height; y+=16) {
802
        for (x=0; x < width; x+=16) {
803
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
804
                                            linesize, pmv, x, y);
805
          if (result != 0)
806
          {
807
#ifdef DEBUG_SVQ1
808
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
809
#endif
810
            return result;
811
          }
812
        }
813

    
814
        pmv[0].x =
815
        pmv[0].y = 0;
816

    
817
        current += 16*linesize;
818
      }
819
    }
820
  }
821

    
822
  *pict = *(AVFrame*)&s->current_picture;
823

    
824

    
825
  MPV_frame_end(s);
826

    
827
  *data_size=sizeof(AVFrame);
828
  return buf_size;
829
}
830

    
831
static int svq1_decode_init(AVCodecContext *avctx)
832
{
833
    MpegEncContext *s = avctx->priv_data;
834
    int i;
835

    
836
    MPV_decode_defaults(s);
837

    
838
    s->avctx = avctx;
839
    s->width = (avctx->width+3)&~3;
840
    s->height = (avctx->height+3)&~3;
841
    s->codec_id= avctx->codec->id;
842
    avctx->pix_fmt = PIX_FMT_YUV410P;
843
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
844
    s->flags= avctx->flags;
845
    if (MPV_common_init(s) < 0) return -1;
846

    
847
    init_vlc(&svq1_block_type, 2, 4,
848
        &svq1_block_type_vlc[0][1], 2, 1,
849
        &svq1_block_type_vlc[0][0], 2, 1, 1);
850

    
851
    init_vlc(&svq1_motion_component, 7, 33,
852
        &mvtab[0][1], 2, 1,
853
        &mvtab[0][0], 2, 1, 1);
854

    
855
    for (i = 0; i < 6; i++) {
856
        init_vlc(&svq1_intra_multistage[i], 3, 8,
857
            &svq1_intra_multistage_vlc[i][0][1], 2, 1,
858
            &svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
859
        init_vlc(&svq1_inter_multistage[i], 3, 8,
860
            &svq1_inter_multistage_vlc[i][0][1], 2, 1,
861
            &svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
862
    }
863

    
864
    init_vlc(&svq1_intra_mean, 8, 256,
865
        &svq1_intra_mean_vlc[0][1], 4, 2,
866
        &svq1_intra_mean_vlc[0][0], 4, 2, 1);
867

    
868
    init_vlc(&svq1_inter_mean, 9, 512,
869
        &svq1_inter_mean_vlc[0][1], 4, 2,
870
        &svq1_inter_mean_vlc[0][0], 4, 2, 1);
871

    
872
    return 0;
873
}
874

    
875
static int svq1_decode_end(AVCodecContext *avctx)
876
{
877
    MpegEncContext *s = avctx->priv_data;
878

    
879
    MPV_common_end(s);
880
    return 0;
881
}
882

    
883
static void svq1_write_header(SVQ1Context *s, int frame_type)
884
{
885
    int i;
886

    
887
    /* frame code */
888
    put_bits(&s->pb, 22, 0x20);
889

    
890
    /* temporal reference (sure hope this is a "don't care") */
891
    put_bits(&s->pb, 8, 0x00);
892

    
893
    /* frame type */
894
    put_bits(&s->pb, 2, frame_type - 1);
895

    
896
    if (frame_type == I_TYPE) {
897

    
898
        /* no checksum since frame code is 0x20 */
899

    
900
        /* no embedded string either */
901

    
902
        /* output 5 unknown bits (2 + 2 + 1) */
903
        put_bits(&s->pb, 5, 0);
904

    
905
        for (i = 0; i < 7; i++)
906
        {
907
            if ((svq1_frame_size_table[i].width == s->frame_width) &&
908
                (svq1_frame_size_table[i].height == s->frame_height))
909
            {
910
                put_bits(&s->pb, 3, i);
911
                break;
912
            }
913
        }
914

    
915
        if (i == 7)
916
        {
917
            put_bits(&s->pb, 3, 7);
918
                put_bits(&s->pb, 12, s->frame_width);
919
                put_bits(&s->pb, 12, s->frame_height);
920
        }
921
    }
922

    
923
    /* no checksum or extra data (next 2 bits get 0) */
924
    put_bits(&s->pb, 2, 0);
925
}
926

    
927

    
928
#define QUALITY_THRESHOLD 100
929
#define THRESHOLD_MULTIPLIER 0.6
930

    
931
#if defined(HAVE_ALTIVEC)
932
#undef vector
933
#endif
934

    
935
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){
936
    int count, y, x, i, j, split, best_mean, best_score, best_count;
937
    int best_vector[6];
938
    int block_sum[7]= {0, 0, 0, 0, 0, 0};
939
    int w= 2<<((level+2)>>1);
940
    int h= 2<<((level+1)>>1);
941
    int size=w*h;
942
    int16_t block[7][256];
943
    const int8_t *codebook_sum, *codebook;
944
    const uint16_t (*mean_vlc)[2];
945
    const uint8_t (*multistage_vlc)[2];
946

    
947
    best_score=0;
948
    //FIXME optimize, this doenst need to be done multiple times
949
    if(intra){
950
        codebook_sum= svq1_intra_codebook_sum[level];
951
        codebook= svq1_intra_codebooks[level];
952
        mean_vlc= svq1_intra_mean_vlc;
953
        multistage_vlc= svq1_intra_multistage_vlc[level];
954
        for(y=0; y<h; y++){
955
            for(x=0; x<w; x++){
956
                int v= src[x + y*stride];
957
                block[0][x + w*y]= v;
958
                best_score += v*v;
959
                block_sum[0] += v;
960
            }
961
        }
962
    }else{
963
        codebook_sum= svq1_inter_codebook_sum[level];
964
        codebook= svq1_inter_codebooks[level];
965
        mean_vlc= svq1_inter_mean_vlc + 256;
966
        multistage_vlc= svq1_inter_multistage_vlc[level];
967
        for(y=0; y<h; y++){
968
            for(x=0; x<w; x++){
969
                int v= src[x + y*stride] - ref[x + y*stride];
970
                block[0][x + w*y]= v;
971
                best_score += v*v;
972
                block_sum[0] += v;
973
            }
974
        }
975
    }
976

    
977
    best_count=0;
978
    best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
979
    best_mean= (block_sum[0] + (size>>1)) >> (level+3);
980

    
981
    if(level<4){
982
        for(count=1; count<7; count++){
983
            int best_vector_score= INT_MAX;
984
            int best_vector_sum=-999, best_vector_mean=-999;
985
            const int stage= count-1;
986
            const int8_t *vector;
987

    
988
            for(i=0; i<16; i++){
989
                int sum= codebook_sum[stage*16 + i];
990
                int sqr=0;
991
                int diff, mean, score;
992

    
993
                vector = codebook + stage*size*16 + i*size;
994

    
995
                for(j=0; j<size; j++){
996
                    int v= vector[j];
997
                    sqr += (v - block[stage][j])*(v - block[stage][j]);
998
                }
999
                diff= block_sum[stage] - sum;
1000
                mean= (diff + (size>>1)) >> (level+3);
1001
                assert(mean >-300 && mean<300);
1002
                if(intra) mean= clip(mean, 0, 255);
1003
                else      mean= clip(mean, -256, 255);
1004
                score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1005
                if(score < best_vector_score){
1006
                    best_vector_score= score;
1007
                    best_vector[stage]= i;
1008
                    best_vector_sum= sum;
1009
                    best_vector_mean= mean;
1010
                }
1011
            }
1012
            assert(best_vector_mean != -999);
1013
            vector= codebook + stage*size*16 + best_vector[stage]*size;
1014
            for(j=0; j<size; j++){
1015
                block[stage+1][j] = block[stage][j] - vector[j];
1016
            }
1017
            block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1018
            best_vector_score +=
1019
                lambda*(+ 1 + 4*count
1020
                        + multistage_vlc[1+count][1]
1021
                        + mean_vlc[best_vector_mean][1]);
1022

    
1023
            if(best_vector_score < best_score){
1024
                best_score= best_vector_score;
1025
                best_count= count;
1026
                best_mean= best_vector_mean;
1027
            }
1028
        }
1029
    }
1030

    
1031
    split=0;
1032
    if(best_score > threshold && level){
1033
        int score=0;
1034
        int offset= (level&1) ? stride*h/2 : w/2;
1035
        PutBitContext backup[6];
1036

    
1037
        for(i=level-1; i>=0; i--){
1038
            backup[i]= s->reorder_pb[i];
1039
        }
1040
        score += encode_block(s, src         , ref         , decoded         , stride, level-1, threshold>>1, lambda, intra);
1041
        score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1042
        score += lambda;
1043

    
1044
        if(score < best_score){
1045
            best_score= score;
1046
            split=1;
1047
        }else{
1048
            for(i=level-1; i>=0; i--){
1049
                s->reorder_pb[i]= backup[i];
1050
            }
1051
        }
1052
    }
1053
    if (level > 0)
1054
        put_bits(&s->reorder_pb[level], 1, split);
1055

    
1056
    if(!split){
1057
        assert((best_mean >= 0 && best_mean<256) || !intra);
1058
        assert(best_mean >= -256 && best_mean<256);
1059
        assert(best_count >=0 && best_count<7);
1060
        assert(level<4 || best_count==0);
1061

    
1062
        /* output the encoding */
1063
        put_bits(&s->reorder_pb[level],
1064
            multistage_vlc[1 + best_count][1],
1065
            multistage_vlc[1 + best_count][0]);
1066
        put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1067
            mean_vlc[best_mean][0]);
1068

    
1069
        for (i = 0; i < best_count; i++){
1070
            assert(best_vector[i]>=0 && best_vector[i]<16);
1071
            put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1072
        }
1073

    
1074
        for(y=0; y<h; y++){
1075
            for(x=0; x<w; x++){
1076
                decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1077
            }
1078
        }
1079
    }
1080

    
1081
    return best_score;
1082
}
1083

    
1084
#ifdef CONFIG_ENCODERS
1085

    
1086
static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1087
    int width, int height, int src_stride, int stride)
1088
{
1089
    int x, y;
1090
    int i;
1091
    int block_width, block_height;
1092
    int level;
1093
    int threshold[6];
1094
    const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1095

    
1096
    /* figure out the acceptable level thresholds in advance */
1097
    threshold[5] = QUALITY_THRESHOLD;
1098
    for (level = 4; level >= 0; level--)
1099
        threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1100

    
1101
    block_width = (width + 15) / 16;
1102
    block_height = (height + 15) / 16;
1103

    
1104
    if(s->picture.pict_type == P_TYPE){
1105
        s->m.avctx= s->avctx;
1106
        s->m.current_picture_ptr= &s->m.current_picture;
1107
        s->m.last_picture_ptr   = &s->m.last_picture;
1108
        s->m.last_picture.data[0]= ref_plane;
1109
        s->m.linesize=
1110
        s->m.last_picture.linesize[0]=
1111
        s->m.new_picture.linesize[0]=
1112
        s->m.current_picture.linesize[0]= stride;
1113
        s->m.width= width;
1114
        s->m.height= height;
1115
        s->m.mb_width= block_width;
1116
        s->m.mb_height= block_height;
1117
        s->m.mb_stride= s->m.mb_width+1;
1118
        s->m.b8_stride= 2*s->m.mb_width+1;
1119
        s->m.f_code=1;
1120
        s->m.pict_type= s->picture.pict_type;
1121
        s->m.me_method= s->avctx->me_method;
1122
        s->m.me.scene_change_score=0;
1123
        s->m.flags= s->avctx->flags;
1124
//        s->m.out_format = FMT_H263;
1125
//        s->m.unrestricted_mv= 1;
1126

    
1127
        s->m.lambda= s->picture.quality;
1128
        s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1129
        s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1130

    
1131
        if(!s->motion_val8[plane]){
1132
            s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1133
            s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1134
        }
1135

    
1136
        s->m.mb_type= s->mb_type;
1137

    
1138
        //dummies, to avoid segfaults
1139
        s->m.current_picture.mb_mean=   (uint8_t *)s->dummy;
1140
        s->m.current_picture.mb_var=    (uint16_t*)s->dummy;
1141
        s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1142
        s->m.current_picture.mb_type= s->dummy;
1143

    
1144
        s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1145
        s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1146
        s->m.dsp= s->dsp; //move
1147
        ff_init_me(&s->m);
1148

    
1149
        s->m.me.dia_size= s->avctx->dia_size;
1150
        s->m.first_slice_line=1;
1151
        for (y = 0; y < block_height; y++) {
1152
            uint8_t src[stride*16];
1153

    
1154
            s->m.new_picture.data[0]= src - y*16*stride; //ugly
1155
            s->m.mb_y= y;
1156

    
1157
            for(i=0; i<16 && i + 16*y<height; i++){
1158
                memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1159
                for(x=width; x<16*block_width; x++)
1160
                    src[i*stride+x]= src[i*stride+x-1];
1161
            }
1162
            for(; i<16 && i + 16*y<16*block_height; i++)
1163
                memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1164

    
1165
            for (x = 0; x < block_width; x++) {
1166
                s->m.mb_x= x;
1167
                ff_init_block_index(&s->m);
1168
                ff_update_block_index(&s->m);
1169

    
1170
                ff_estimate_p_frame_motion(&s->m, x, y);
1171
            }
1172
            s->m.first_slice_line=0;
1173
        }
1174

    
1175
        ff_fix_long_p_mvs(&s->m);
1176
        ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1177
    }
1178

    
1179
    s->m.first_slice_line=1;
1180
    for (y = 0; y < block_height; y++) {
1181
        uint8_t src[stride*16];
1182

    
1183
        for(i=0; i<16 && i + 16*y<height; i++){
1184
            memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1185
            for(x=width; x<16*block_width; x++)
1186
                src[i*stride+x]= src[i*stride+x-1];
1187
        }
1188
        for(; i<16 && i + 16*y<16*block_height; i++)
1189
            memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1190

    
1191
        s->m.mb_y= y;
1192
        for (x = 0; x < block_width; x++) {
1193
            uint8_t reorder_buffer[3][6][7*32];
1194
            int count[3][6];
1195
            int offset = y * 16 * stride + x * 16;
1196
            uint8_t *decoded= decoded_plane + offset;
1197
            uint8_t *ref= ref_plane + offset;
1198
            int score[4]={0,0,0,0}, best;
1199
            uint8_t temp[16*stride];
1200

    
1201
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
1202
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1203
                return -1;
1204
            }
1205

    
1206
            s->m.mb_x= x;
1207
            ff_init_block_index(&s->m);
1208
            ff_update_block_index(&s->m);
1209

    
1210
            if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1211
                for(i=0; i<6; i++){
1212
                    init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1213
                }
1214
                if(s->picture.pict_type == P_TYPE){
1215
                    const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1216
                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1217
                    score[0]= vlc[1]*lambda;
1218
                }
1219
                score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1220
                for(i=0; i<6; i++){
1221
                    count[0][i]= put_bits_count(&s->reorder_pb[i]);
1222
                    flush_put_bits(&s->reorder_pb[i]);
1223
                }
1224
            }else
1225
                score[0]= INT_MAX;
1226

    
1227
            best=0;
1228

    
1229
            if(s->picture.pict_type == P_TYPE){
1230
                const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1231
                int mx, my, pred_x, pred_y, dxy;
1232
                int16_t *motion_ptr;
1233

    
1234
                motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1235
                if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1236
                    for(i=0; i<6; i++)
1237
                        init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1238

    
1239
                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1240

    
1241
                    s->m.pb= s->reorder_pb[5];
1242
                    mx= motion_ptr[0];
1243
                    my= motion_ptr[1];
1244
                    assert(mx>=-32 && mx<=31);
1245
                    assert(my>=-32 && my<=31);
1246
                    assert(pred_x>=-32 && pred_x<=31);
1247
                    assert(pred_y>=-32 && pred_y<=31);
1248
                    ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1249
                    ff_h263_encode_motion(&s->m, my - pred_y, 1);
1250
                    s->reorder_pb[5]= s->m.pb;
1251
                    score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1252

    
1253
                    dxy= (mx&1) + 2*(my&1);
1254

    
1255
                    s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1256

    
1257
                    score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1258
                    best= score[1] <= score[0];
1259

    
1260
                    vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1261
                    score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1262
                    score[2]+= vlc[1]*lambda;
1263
                    if(score[2] < score[best] && mx==0 && my==0){
1264
                        best=2;
1265
                        s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1266
                        for(i=0; i<6; i++){
1267
                            count[2][i]=0;
1268
                        }
1269
                        put_bits(&s->pb, vlc[1], vlc[0]);
1270
                    }
1271
                }
1272

    
1273
                if(best==1){
1274
                    for(i=0; i<6; i++){
1275
                        count[1][i]= put_bits_count(&s->reorder_pb[i]);
1276
                        flush_put_bits(&s->reorder_pb[i]);
1277
                    }
1278
                }else{
1279
                    motion_ptr[0                 ] = motion_ptr[1                 ]=
1280
                    motion_ptr[2                 ] = motion_ptr[3                 ]=
1281
                    motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1282
                    motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1283
                }
1284
            }
1285

    
1286
            s->rd_total += score[best];
1287

    
1288
            for(i=5; i>=0; i--){
1289
                ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1290
            }
1291
            if(best==0){
1292
                s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1293
            }
1294
        }
1295
        s->m.first_slice_line=0;
1296
    }
1297
    return 0;
1298
}
1299

    
1300
static int svq1_encode_init(AVCodecContext *avctx)
1301
{
1302
    SVQ1Context * const s = avctx->priv_data;
1303

    
1304
    dsputil_init(&s->dsp, avctx);
1305
    avctx->coded_frame= (AVFrame*)&s->picture;
1306

    
1307
    s->frame_width = avctx->width;
1308
    s->frame_height = avctx->height;
1309

    
1310
    s->y_block_width = (s->frame_width + 15) / 16;
1311
    s->y_block_height = (s->frame_height + 15) / 16;
1312

    
1313
    s->c_block_width = (s->frame_width / 4 + 15) / 16;
1314
    s->c_block_height = (s->frame_height / 4 + 15) / 16;
1315

    
1316
    s->avctx= avctx;
1317
    s->m.avctx= avctx;
1318
    s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
1319
    s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1320
    s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1321
    s->mb_type        = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1322
    s->dummy          = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1323
    h263_encode_init(&s->m); //mv_penalty
1324

    
1325
    return 0;
1326
}
1327

    
1328
static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
1329
    int buf_size, void *data)
1330
{
1331
    SVQ1Context * const s = avctx->priv_data;
1332
    AVFrame *pict = data;
1333
    AVFrame * const p= (AVFrame*)&s->picture;
1334
    AVFrame temp;
1335
    int i;
1336

    
1337
    if(avctx->pix_fmt != PIX_FMT_YUV410P){
1338
        av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1339
        return -1;
1340
    }
1341

    
1342
    if(!s->current_picture.data[0]){
1343
        avctx->get_buffer(avctx, &s->current_picture);
1344
        avctx->get_buffer(avctx, &s->last_picture);
1345
    }
1346

    
1347
    temp= s->current_picture;
1348
    s->current_picture= s->last_picture;
1349
    s->last_picture= temp;
1350

    
1351
    init_put_bits(&s->pb, buf, buf_size);
1352

    
1353
    *p = *pict;
1354
    p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1355
    p->key_frame = p->pict_type == I_TYPE;
1356

    
1357
    svq1_write_header(s, p->pict_type);
1358
    for(i=0; i<3; i++){
1359
        if(svq1_encode_plane(s, i,
1360
            s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1361
            s->frame_width / (i?4:1), s->frame_height / (i?4:1),
1362
            s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
1363
                return -1;
1364
    }
1365

    
1366
//    align_put_bits(&s->pb);
1367
    while(put_bits_count(&s->pb) & 31)
1368
        put_bits(&s->pb, 1, 0);
1369

    
1370
    flush_put_bits(&s->pb);
1371

    
1372
    return (put_bits_count(&s->pb) / 8);
1373
}
1374

    
1375
static int svq1_encode_end(AVCodecContext *avctx)
1376
{
1377
    SVQ1Context * const s = avctx->priv_data;
1378
    int i;
1379

    
1380
    av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1381

    
1382
    av_freep(&s->m.me.scratchpad);
1383
    av_freep(&s->m.me.map);
1384
    av_freep(&s->m.me.score_map);
1385
    av_freep(&s->mb_type);
1386
    av_freep(&s->dummy);
1387

    
1388
    for(i=0; i<3; i++){
1389
        av_freep(&s->motion_val8[i]);
1390
        av_freep(&s->motion_val16[i]);
1391
    }
1392

    
1393
    return 0;
1394
}
1395

    
1396
#endif //CONFIG_ENCODERS
1397

    
1398
AVCodec svq1_decoder = {
1399
    "svq1",
1400
    CODEC_TYPE_VIDEO,
1401
    CODEC_ID_SVQ1,
1402
    sizeof(MpegEncContext),
1403
    svq1_decode_init,
1404
    NULL,
1405
    svq1_decode_end,
1406
    svq1_decode_frame,
1407
    CODEC_CAP_DR1,
1408
    .flush= ff_mpeg_flush,
1409
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1410
};
1411

    
1412
#ifdef CONFIG_ENCODERS
1413

    
1414
AVCodec svq1_encoder = {
1415
    "svq1",
1416
    CODEC_TYPE_VIDEO,
1417
    CODEC_ID_SVQ1,
1418
    sizeof(SVQ1Context),
1419
    svq1_encode_init,
1420
    svq1_encode_frame,
1421
    svq1_encode_end,
1422
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1423
};
1424

    
1425
#endif //CONFIG_ENCODERS