Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1.c @ 983e3246

History | View | Annotate | Download (53.3 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20
 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
21
 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
22
 *
23
 */
24

    
25
/**
26
 * @file svq1.c
27
 * svq1 decoder.
28
 */
29

    
30
//#define DEBUG_SVQ1
31
#include <stdio.h>
32
#include <stdlib.h>
33
#include <string.h>
34
#include <unistd.h>
35

    
36
#include "common.h"
37
#include "avcodec.h"
38
#include "dsputil.h"
39
#include "mpegvideo.h"
40
#include "bswap.h"
41
#define bit_buffer_t GetBitContext
42

    
43
static inline unsigned int get_bit_cache(GetBitContext *s){
44
    OPEN_READER(re, s)
45
    UPDATE_CACHE(re, s)
46
    return GET_CACHE(re, s);
47
//    CLOSE_READER(re, s)
48
}
49

    
50
/* variable length (bit) code */
51
typedef struct vlc_code_s {
52
  int16_t         value        :10,
53
                 length        :6;
54
} vlc_code_t;
55

    
56
#define MEDIAN(a,b,c)        (((a < b) != (b >= c)) ? b : (((a < c) != (c > b)) ? c : a))
57

    
58
#define SVQ1_BLOCK_SKIP                0
59
#define SVQ1_BLOCK_INTER        1
60
#define SVQ1_BLOCK_INTER_4V        2
61
#define SVQ1_BLOCK_INTRA        3
62

    
63
/* motion vector (prediction) */
64
typedef struct svq1_pmv_s {
65
  int                 x;
66
  int                 y;
67
} svq1_pmv_t;
68

    
69
#include "svq1_cb.h"
70

    
71
/* block type, codes 000 .. 1xx */
72
static vlc_code_t svq1_block_type_table[8] = {
73
  { SVQ1_BLOCK_INTRA, 3 }, { SVQ1_BLOCK_INTER_4V, 3 },
74
  { SVQ1_BLOCK_INTER, 2 }, { SVQ1_BLOCK_INTER,    2 },
75
  { SVQ1_BLOCK_SKIP,  1 }, { SVQ1_BLOCK_SKIP,     1 },
76
  { SVQ1_BLOCK_SKIP,  1 }, { SVQ1_BLOCK_SKIP,     1 }
77
};
78

    
79
/* motion vector, codes 0000011 .. 011xxxx */
80
static vlc_code_t svq1_motion_table_0[61] = {
81
  { 7, 8 }, { 6, 8 }, { 5, 8 }, { 4, 7 }, { 4, 7 },
82
  { 3, 5 }, { 3, 5 }, { 3, 5 }, { 3, 5 }, { 3, 5 }, { 3, 5 }, { 3, 5 }, { 3, 5 },
83
  { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 },
84
  { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 },
85
  { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
86
  { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
87
  { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
88
  { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }
89
};
90

    
91
/* motion vector, codes 000000000010 ... 0000010111xx */
92
static vlc_code_t svq1_motion_table_1[94] = {
93
  {32, 13}, {31, 13}, {30, 12}, {30, 12}, {29, 12}, {29, 12},
94
  {28, 12}, {28, 12}, {27, 12}, {27, 12}, {26, 12}, {26, 12}, {25, 12}, {25, 12},
95
  {24, 11}, {24, 11}, {24, 11}, {24, 11}, {23, 11}, {23, 11}, {23, 11}, {23, 11},
96
  {22, 11}, {22, 11}, {22, 11}, {22, 11}, {21, 11}, {21, 11}, {21, 11}, {21, 11},
97
  {20, 11}, {20, 11}, {20, 11}, {20, 11}, {19, 11}, {19, 11}, {19, 11}, {19, 11},
98
  {18, 11}, {18, 11}, {18, 11}, {18, 11}, {17, 11}, {17, 11}, {17, 11}, {17, 11},
99
  {16, 11}, {16, 11}, {16, 11}, {16, 11}, {15, 11}, {15, 11}, {15, 11}, {15, 11},
100
  {14, 11}, {14, 11}, {14, 11}, {14, 11}, {13, 11}, {13, 11}, {13, 11}, {13, 11},
101
  {12, 11}, {12, 11}, {12, 11}, {12, 11}, {11, 11}, {11, 11}, {11, 11}, {11, 11},
102
  {10, 10}, {10, 10}, {10, 10}, {10, 10}, {10, 10}, {10, 10}, {10, 10}, {10, 10},
103
  { 9, 10}, { 9, 10}, { 9, 10}, { 9, 10}, { 9, 10}, { 9, 10}, { 9, 10}, { 9, 10},
104
  { 8, 10}, { 8, 10}, { 8, 10}, { 8, 10}, { 8, 10}, { 8, 10}, { 8, 10}, { 8, 10},
105
};
106

    
107
/* inter-coded vector codebook count tables, codes 000000 ... 111111 */
108
static vlc_code_t svq1_inter_vector_tables[6][64] = {
109
  /* 4x2 vector, codes 0000xxx ... 11xxxxx */
110
  { { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 },
111
    { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 },
112
    { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 },
113
    { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 },
114
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
115
    { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 },
116
    {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 },
117
    {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 } },
118

    
119
  /* 4x4 vector, codes 0000xxx ... 11xxxxx */
120
  { { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 },
121
    { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 },
122
    { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 },
123
    { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 },
124
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
125
    { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 },
126
    {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 },
127
    {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 }, {-1, 2 } },
128

    
129
  /* 8x4 vector, codes 00000xx ... 1xxxxxx */
130
  { { 6, 5 }, { 6, 5 }, { 5, 5 }, { 5, 5 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 },
131
    { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 },
132
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
133
    { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 },
134
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
135
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
136
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
137
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 } },
138

    
139
  /* 8x8 vector, codes 00000xx ... 1xxxxxx */
140
  { { 6, 5 }, { 6, 5 }, { 5, 5 }, { 5, 5 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 },
141
    { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 },
142
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
143
    { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 },
144
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
145
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
146
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
147
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 } },
148

    
149
  /* 16x8 vector, codes 00000xx ... 1xxxxxx */
150
  { { 6, 5 }, { 6, 5 }, { 5, 5 }, { 5, 5 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 },
151
    { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 }, { 2, 4 },
152
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
153
    { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 },
154
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
155
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
156
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
157
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 } },
158

    
159
  /* 16x16 vector, codes 000000x ... 1xxxxxx */
160
  { { 6, 6 }, { 5, 6 }, { 4, 5 }, { 4, 5 }, { 3, 5 }, { 3, 5 }, { 2, 5 }, { 2, 5 },
161
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
162
    { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 },
163
    { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 },
164
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
165
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
166
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 },
167
    {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 }, {-1, 1 } }
168
};
169

    
170
/* vector codebook count tables, codes 0000000 ... 1111111 */
171
static vlc_code_t svq1_intra_vector_tables[6][128] = {
172
  /* 4x2 vector, codes 00000xx ... 1xxxxxx */
173
  { { 5, 5 }, { 5, 5 }, { 5, 5 }, { 5, 5 }, {-1, 5 }, {-1, 5 }, {-1, 5 }, {-1, 5 },
174
    { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 },
175
    { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 },
176
    { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 },
177
    { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 },
178
    { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 },
179
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
180
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
181
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
182
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
183
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
184
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
185
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
186
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
187
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
188
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 } },
189

    
190
  /* 4x4 vector, codes 0000xxx ... 11xxxxx */
191
  { { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 },
192
    {-1, 4 }, {-1, 4 }, {-1, 4 }, {-1, 4 }, {-1, 4 }, {-1, 4 }, {-1, 4 }, {-1, 4 },
193
    { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 },
194
    { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 },
195
    { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 },
196
    { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 },
197
    { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 },
198
    { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 }, { 3, 3 },
199
    { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 },
200
    { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 },
201
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
202
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
203
    { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 },
204
    { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 },
205
    { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 },
206
    { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 2 } },
207

    
208
  /* 8x4 vector, codes 00000xx ... 1xxxxxx */
209
  { { 2, 5 }, { 2, 5 }, { 2, 5 }, { 2, 5 }, {-1, 5 }, {-1, 5 }, {-1, 5 }, {-1, 5 },
210
    { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 },
211
    { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 }, { 5, 4 },
212
    { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 },
213
    { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 },
214
    { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 }, { 4, 3 },
215
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },
216
    { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 }, { 1, 3 },  
217
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
218
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
219
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
220
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
221
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
222
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
223
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
224
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 } },
225

    
226
  /* 8x8 vector, codes 000000x ... 1xxxxxx */
227
  { { 2, 6 }, { 2, 6 }, {-1, 6 }, {-1, 6 }, { 5, 5 }, { 5, 5 }, { 5, 5 }, { 5, 5 },
228
    { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 }, { 6, 4 },
229
    { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 }, { 4, 4 },
230
    { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 },
231
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
232
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
233
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
234
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
235
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
236
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
237
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
238
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
239
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
240
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
241
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
242
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 } },
243

    
244
  /* 16x8 vector, codes 000000x ... 1xxxxxx */
245
  { { 4, 6 }, { 4, 6 }, {-1, 6 }, {-1, 6 }, { 5, 5 }, { 5, 5 }, { 5, 5 }, { 5, 5 },
246
    { 3, 5 }, { 3, 5 }, { 3, 5 }, { 3, 5 }, { 2, 5 }, { 2, 5 }, { 2, 5 }, { 2, 5 },
247
    { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 },
248
    { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 }, { 6, 3 },
249
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
250
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
251
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
252
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
253
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
254
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
255
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
256
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
257
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
258
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
259
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
260
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 } },
261

    
262
  /* 16x16 vector, codes 0000000 ... 1xxxxxx */
263
  { { 5, 7 }, {-1, 7 }, { 4, 6 }, { 4, 6 }, { 6, 5 }, { 6, 5 }, { 6, 5 }, { 6, 5 },
264
    { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 }, { 3, 4 },
265
    { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 },
266
    { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 }, { 2, 3 },
267
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
268
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
269
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
270
    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 },
271
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
272
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
273
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
274
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
275
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
276
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
277
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 },
278
    { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 } }
279
};
280

    
281
/* intra mean value, codes 00100101 ... 1111xxxx */
282
static vlc_code_t svq1_intra_mean_table_0[219] = {
283
  {135, 8 }, {136, 8 }, {165, 8 },
284
  {134, 8 }, {129, 8 }, {164, 8 }, {163, 8 }, {133, 8 }, {162, 8 }, {174, 8 }, {175, 8 },
285
  {161, 8 }, {160, 8 }, {159, 8 }, {158, 8 }, {157, 8 }, {156, 8 }, {155, 8 }, {154, 8 },
286
  {153, 8 }, {151, 8 }, {152, 8 }, {132, 8 }, {110, 8 }, {131, 8 }, {108, 8 }, {130, 8 },
287
  {166, 8 }, {105, 8 }, {104, 8 }, {103, 8 }, {127, 8 }, {101, 8 }, {167, 8 }, {168, 8 },
288
  { 98, 8 }, {128, 8 }, { 48, 8 }, { 95, 8 }, { 62, 8 }, { 93, 8 }, { 92, 8 }, { 91, 8 },
289
  { 90, 8 }, { 89, 8 }, { 60, 8 }, { 87, 8 }, { 86, 8 }, { 57, 8 }, { 84, 8 }, { 83, 8 },
290
  { 82, 8 }, { 81, 8 }, { 80, 8 }, { 79, 8 }, { 78, 8 }, { 77, 8 }, { 76, 8 }, { 75, 8 },
291
  { 74, 8 }, { 73, 8 }, { 72, 8 }, { 71, 8 }, { 70, 8 }, { 69, 8 }, { 68, 8 }, { 67, 8 },
292
  { 66, 8 }, { 65, 8 }, { 56, 8 }, { 63, 8 }, { 23, 8 }, { 61, 8 }, { 30, 8 }, { 59, 8 },
293
  { 58, 8 }, { 52, 8 }, { 29, 8 }, { 55, 8 }, { 54, 8 }, { 53, 8 }, { 50, 8 }, { 51, 8 },
294
  { 22, 8 }, { 49, 8 }, { 85, 7 }, { 85, 7 }, { 97, 7 }, { 97, 7 }, { 88, 7 }, { 88, 7 },
295
  { 64, 7 }, { 64, 7 }, { 94, 7 }, { 94, 7 }, {106, 7 }, {106, 7 }, {107, 7 }, {107, 7 },
296
  {109, 7 }, {109, 7 }, {111, 7 }, {111, 7 }, {112, 7 }, {112, 7 }, {113, 7 }, {113, 7 },
297
  {114, 7 }, {114, 7 }, {115, 7 }, {115, 7 }, {116, 7 }, {116, 7 }, {117, 7 }, {117, 7 },
298
  {118, 7 }, {118, 7 }, {119, 7 }, {119, 7 }, {120, 7 }, {120, 7 }, { 99, 7 }, { 99, 7 },
299
  {102, 7 }, {102, 7 }, { 28, 7 }, { 28, 7 }, {100, 7 }, {100, 7 }, { 96, 7 }, { 96, 7 },
300
  {139, 7 }, {139, 7 }, { 24, 7 }, { 24, 7 }, {  1, 7 }, {  1, 7 }, {138, 7 }, {138, 7 },
301
  {121, 7 }, {121, 7 }, {122, 7 }, {122, 7 }, {123, 7 }, {123, 7 }, {124, 7 }, {124, 7 },
302
  {125, 7 }, {125, 7 }, {126, 7 }, {126, 7 }, {137, 7 }, {137, 7 }, {140, 7 }, {140, 7 },
303
  {150, 7 }, {150, 7 }, {144, 7 }, {144, 7 }, {141, 7 }, {141, 7 }, {142, 7 }, {142, 7 },
304
  {143, 7 }, {143, 7 }, {145, 7 }, {145, 7 }, {147, 7 }, {147, 7 }, {146, 7 }, {146, 7 },
305
  { 27, 6 }, { 27, 6 }, { 27, 6 }, { 27, 6 }, {148, 6 }, {148, 6 }, {148, 6 }, {148, 6 },
306
  {149, 6 }, {149, 6 }, {149, 6 }, {149, 6 }, {  0, 6 }, {  0, 6 }, {  0, 6 }, {  0, 6 },
307
  { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 },
308
  { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 }, { 26, 4 },
309
  { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 },
310
  { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }, { 25, 4 }
311
};
312

    
313
/* intra mean value, codes 0000001101 ... 001001001x */
314
static vlc_code_t svq1_intra_mean_table_1[135] = {
315
  {218, 10}, {219, 10}, {220, 10},
316
  {221, 10}, {222, 10}, {217, 10}, {230, 10}, {215, 10}, {208, 10}, {207, 10}, {206, 10},
317
  {214, 10}, {204, 10}, {223, 10}, {224, 10}, {225, 10}, {226, 10}, {227, 10}, {228, 10},
318
  {229, 10}, {213, 10}, {212, 10}, {231, 10}, {232, 10}, {211, 10}, {210, 10}, {236, 10},
319
  {209, 10}, {216, 10}, {205, 10}, { 18, 10}, {186, 9 }, {186, 9 }, {185, 9 }, {185, 9 },
320
  {184, 9 }, {184, 9 }, {182, 9 }, {182, 9 }, {183, 9 }, {183, 9 }, {180, 9 }, {180, 9 },
321
  {181, 9 }, {181, 9 }, {178, 9 }, {178, 9 }, {187, 9 }, {187, 9 }, {176, 9 }, {176, 9 },
322
  {188, 9 }, {188, 9 }, {179, 9 }, {179, 9 }, {173, 9 }, {173, 9 }, {172, 9 }, {172, 9 },
323
  {171, 9 }, {171, 9 }, {170, 9 }, {170, 9 }, {169, 9 }, {169, 9 }, {189, 9 }, {189, 9 },
324
  {190, 9 }, {190, 9 }, {191, 9 }, {191, 9 }, {192, 9 }, {192, 9 }, {193, 9 }, {193, 9 },
325
  {194, 9 }, {194, 9 }, {195, 9 }, {195, 9 }, {196, 9 }, {196, 9 }, {197, 9 }, {197, 9 },
326
  {198, 9 }, {198, 9 }, {200, 9 }, {200, 9 }, {201, 9 }, {201, 9 }, {202, 9 }, {202, 9 },
327
  {203, 9 }, {203, 9 }, {199, 9 }, {199, 9 }, {177, 9 }, {177, 9 }, { 40, 9 }, { 40, 9 },
328
  { 39, 9 }, { 39, 9 }, { 38, 9 }, { 38, 9 }, { 37, 9 }, { 37, 9 }, { 36, 9 }, { 36, 9 },
329
  { 35, 9 }, { 35, 9 }, { 34, 9 }, { 34, 9 }, { 33, 9 }, { 33, 9 }, { 32, 9 }, { 32, 9 },
330
  { 31, 9 }, { 31, 9 }, { 21, 9 }, { 21, 9 }, { 11, 9 }, { 11, 9 }, { 41, 9 }, { 41, 9 },
331
  { 45, 9 }, { 45, 9 }, { 44, 9 }, { 44, 9 }, { 42, 9 }, { 42, 9 }, { 43, 9 }, { 43, 9 },
332
  { 47, 9 }, { 47, 9 }, { 46, 9 }, { 46, 9 }
333
};
334

    
335
/* intra mean value, codes 00000000000001 ... 00000011001xxx */
336
static vlc_code_t svq1_intra_mean_table_2[207] = {
337
  {255, 14}, { 14, 14}, { 13, 14}, { 17, 12}, { 17, 12}, { 17, 12}, { 17, 12},
338
  {243, 11}, {243, 11}, {243, 11}, {243, 11}, {243, 11}, {243, 11}, {243, 11}, {243, 11},
339
  {242, 11}, {242, 11}, {242, 11}, {242, 11}, {242, 11}, {242, 11}, {242, 11}, {242, 11},
340
  {241, 11}, {241, 11}, {241, 11}, {241, 11}, {241, 11}, {241, 11}, {241, 11}, {241, 11},
341
  {240, 11}, {240, 11}, {240, 11}, {240, 11}, {240, 11}, {240, 11}, {240, 11}, {240, 11},
342
  {237, 11}, {237, 11}, {237, 11}, {237, 11}, {237, 11}, {237, 11}, {237, 11}, {237, 11},
343
  {239, 11}, {239, 11}, {239, 11}, {239, 11}, {239, 11}, {239, 11}, {239, 11}, {239, 11},
344
  {235, 11}, {235, 11}, {235, 11}, {235, 11}, {235, 11}, {235, 11}, {235, 11}, {235, 11},
345
  {234, 11}, {234, 11}, {234, 11}, {234, 11}, {234, 11}, {234, 11}, {234, 11}, {234, 11},
346
  {233, 11}, {233, 11}, {233, 11}, {233, 11}, {233, 11}, {233, 11}, {233, 11}, {233, 11},
347
  {244, 11}, {244, 11}, {244, 11}, {244, 11}, {244, 11}, {244, 11}, {244, 11}, {244, 11},
348
  {238, 11}, {238, 11}, {238, 11}, {238, 11}, {238, 11}, {238, 11}, {238, 11}, {238, 11},
349
  { 20, 11}, { 20, 11}, { 20, 11}, { 20, 11}, { 20, 11}, { 20, 11}, { 20, 11}, { 20, 11},
350
  {248, 11}, {248, 11}, {248, 11}, {248, 11}, {248, 11}, {248, 11}, {248, 11}, {248, 11},
351
  {249, 11}, {249, 11}, {249, 11}, {249, 11}, {249, 11}, {249, 11}, {249, 11}, {249, 11},
352
  {250, 11}, {250, 11}, {250, 11}, {250, 11}, {250, 11}, {250, 11}, {250, 11}, {250, 11},
353
  {251, 11}, {251, 11}, {251, 11}, {251, 11}, {251, 11}, {251, 11}, {251, 11}, {251, 11},
354
  {252, 11}, {252, 11}, {252, 11}, {252, 11}, {252, 11}, {252, 11}, {252, 11}, {252, 11},
355
  {253, 11}, {253, 11}, {253, 11}, {253, 11}, {253, 11}, {253, 11}, {253, 11}, {253, 11},
356
  {254, 11}, {254, 11}, {254, 11}, {254, 11}, {254, 11}, {254, 11}, {254, 11}, {254, 11},
357
  { 12, 11}, { 12, 11}, { 12, 11}, { 12, 11}, { 12, 11}, { 12, 11}, { 12, 11}, { 12, 11},
358
  { 10, 11}, { 10, 11}, { 10, 11}, { 10, 11}, { 10, 11}, { 10, 11}, { 10, 11}, { 10, 11},
359
  {245, 11}, {245, 11}, {245, 11}, {245, 11}, {245, 11}, {245, 11}, {245, 11}, {245, 11},
360
  {247, 11}, {247, 11}, {247, 11}, {247, 11}, {247, 11}, {247, 11}, {247, 11}, {247, 11},
361
  { 19, 11}, { 19, 11}, { 19, 11}, { 19, 11}, { 19, 11}, { 19, 11}, { 19, 11}, { 19, 11},
362
  {246, 11}, {246, 11}, {246, 11}, {246, 11}, {246, 11}, {246, 11}, {246, 11}, {246, 11}
363
};
364

    
365
/* intra mean value, codes 00000000000000000000 ... 000000000000001xxxxx */
366
static vlc_code_t svq1_intra_mean_table_3[64] = {
367
  {  6, 20}, {  3, 20}, {  4, 20}, {  5, 20}, {  7, 20}, {  8, 20}, {  9, 19}, {  9, 19},
368
  {  2, 17}, {  2, 17}, {  2, 17}, {  2, 17}, {  2, 17}, {  2, 17}, {  2, 17}, {  2, 17},
369
  { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16},
370
  { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16}, { 16, 16},
371
  { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15},
372
  { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15},
373
  { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15},
374
  { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}, { 15, 15}
375
};
376

    
377
/* inter mean value, codes 00001011 ... 1xxxxxxx */
378
static vlc_code_t svq1_inter_mean_table_0[245] = {
379
  { 10, 8 }, { 12, 8 }, { 11, 8 }, {-11, 8 }, {-12, 8 },
380
  {-10, 8 }, { -9, 8 }, { -7, 7 }, { -7, 7 }, { -6, 7 }, { -6, 7 }, {  8, 7 }, {  8, 7 },
381
  { -8, 7 }, { -8, 7 }, {  9, 7 }, {  9, 7 }, {  6, 7 }, {  6, 7 }, {  7, 7 }, {  7, 7 },
382
  { -5, 6 }, { -5, 6 }, { -5, 6 }, { -5, 6 }, { -4, 6 }, { -4, 6 }, { -4, 6 }, { -4, 6 },
383
  {  5, 6 }, {  5, 6 }, {  5, 6 }, {  5, 6 }, {  4, 6 }, {  4, 6 }, {  4, 6 }, {  4, 6 },
384
  {  3, 5 }, {  3, 5 }, {  3, 5 }, {  3, 5 }, {  3, 5 }, {  3, 5 }, {  3, 5 }, {  3, 5 },
385
  {  2, 5 }, {  2, 5 }, {  2, 5 }, {  2, 5 }, {  2, 5 }, {  2, 5 }, {  2, 5 }, {  2, 5 },
386
  { -2, 5 }, { -2, 5 }, { -2, 5 }, { -2, 5 }, { -2, 5 }, { -2, 5 }, { -2, 5 }, { -2, 5 },
387
  { -3, 5 }, { -3, 5 }, { -3, 5 }, { -3, 5 }, { -3, 5 }, { -3, 5 }, { -3, 5 }, { -3, 5 },
388
  { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 },
389
  { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 }, { -1, 4 },
390
  {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 },
391
  {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 },
392
  {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 },
393
  {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 }, {  1, 3 },
394
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
395
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
396
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
397
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
398
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
399
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
400
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
401
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
402
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
403
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
404
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
405
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
406
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
407
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
408
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 },
409
  {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }, {  0, 1 }
410
};
411

    
412
/* inter mean value, codes 000000010010 ... 00001011xxxx */
413
static vlc_code_t svq1_inter_mean_table_1[158] = {
414
  {-30, 12}, {-31, 12}, {-32, 12}, {-33, 12}, { 31, 12}, {-34, 12},
415
  {-35, 12}, { 29, 12}, { 30, 12}, { 33, 12}, { 34, 12}, { 32, 12}, {-29, 11}, {-29, 11},
416
  {-28, 11}, {-28, 11}, { 28, 11}, { 28, 11}, {-27, 11}, {-27, 11}, {-26, 11}, {-26, 11},
417
  { 27, 11}, { 27, 11}, { 26, 11}, { 26, 11}, { 25, 11}, { 25, 11}, { 24, 11}, { 24, 11},
418
  { 23, 11}, { 23, 11}, { 22, 11}, { 22, 11}, {-24, 11}, {-24, 11}, {-25, 11}, {-25, 11},
419
  {-23, 10}, {-23, 10}, {-23, 10}, {-23, 10}, {-21, 10}, {-21, 10}, {-21, 10}, {-21, 10},
420
  {-20, 10}, {-20, 10}, {-20, 10}, {-20, 10}, {-19, 10}, {-19, 10}, {-19, 10}, {-19, 10},
421
  {-18, 10}, {-18, 10}, {-18, 10}, {-18, 10}, {-22, 10}, {-22, 10}, {-22, 10}, {-22, 10},
422
  { 19, 10}, { 19, 10}, { 19, 10}, { 19, 10}, { 21, 10}, { 21, 10}, { 21, 10}, { 21, 10},
423
  { 20, 10}, { 20, 10}, { 20, 10}, { 20, 10}, { 18, 10}, { 18, 10}, { 18, 10}, { 18, 10},
424
  {-14, 9 }, {-14, 9 }, {-14, 9 }, {-14, 9 }, {-14, 9 }, {-14, 9 }, {-14, 9 }, {-14, 9 },
425
  {-17, 9 }, {-17, 9 }, {-17, 9 }, {-17, 9 }, {-17, 9 }, {-17, 9 }, {-17, 9 }, {-17, 9 },
426
  { 16, 9 }, { 16, 9 }, { 16, 9 }, { 16, 9 }, { 16, 9 }, { 16, 9 }, { 16, 9 }, { 16, 9 },
427
  { 13, 9 }, { 13, 9 }, { 13, 9 }, { 13, 9 }, { 13, 9 }, { 13, 9 }, { 13, 9 }, { 13, 9 },
428
  { 14, 9 }, { 14, 9 }, { 14, 9 }, { 14, 9 }, { 14, 9 }, { 14, 9 }, { 14, 9 }, { 14, 9 },
429
  { 15, 9 }, { 15, 9 }, { 15, 9 }, { 15, 9 }, { 15, 9 }, { 15, 9 }, { 15, 9 }, { 15, 9 },
430
  { 17, 9 }, { 17, 9 }, { 17, 9 }, { 17, 9 }, { 17, 9 }, { 17, 9 }, { 17, 9 }, { 17, 9 },
431
  {-13, 9 }, {-13, 9 }, {-13, 9 }, {-13, 9 }, {-13, 9 }, {-13, 9 }, {-13, 9 }, {-13, 9 },
432
  {-16, 9 }, {-16, 9 }, {-16, 9 }, {-16, 9 }, {-16, 9 }, {-16, 9 }, {-16, 9 }, {-16, 9 },
433
  {-15, 9 }, {-15, 9 }, {-15, 9 }, {-15, 9 }, {-15, 9 }, {-15, 9 }, {-15, 9 }, {-15, 9 }
434
};
435

    
436
/* inter mean value, codes 000000000010111 ... 0000000100011xx */
437
static vlc_code_t svq1_inter_mean_table_2[121] = {
438
  { 61, 15},
439
  { 52, 15}, { 58, 15}, {-56, 15}, {-57, 15}, { 59, 15}, {-55, 15}, { 60, 15}, {-54, 15},
440
  { 53, 15}, {-62, 15}, {-60, 15}, {-59, 15}, {-58, 15}, { 57, 15}, { 56, 15}, {-53, 15},
441
  { 55, 15}, { 54, 15}, { 50, 14}, { 50, 14}, { 45, 14}, { 45, 14}, {-52, 14}, {-52, 14},
442
  {-51, 14}, {-51, 14}, {-50, 14}, {-50, 14}, { 46, 14}, { 46, 14}, {-49, 14}, {-49, 14},
443
  {-48, 14}, {-48, 14}, { 48, 14}, { 48, 14}, {-47, 14}, {-47, 14}, { 49, 14}, { 49, 14},
444
  {-45, 14}, {-45, 14}, {-44, 14}, {-44, 14}, { 47, 14}, { 47, 14}, { 51, 14}, { 51, 14},
445
  { 44, 14}, { 44, 14}, {-46, 14}, {-46, 14}, {-43, 13}, {-43, 13}, {-43, 13}, {-43, 13},
446
  {-42, 13}, {-42, 13}, {-42, 13}, {-42, 13}, {-41, 13}, {-41, 13}, {-41, 13}, {-41, 13},
447
  {-40, 13}, {-40, 13}, {-40, 13}, {-40, 13}, {-39, 13}, {-39, 13}, {-39, 13}, {-39, 13},
448
  {-38, 13}, {-38, 13}, {-38, 13}, {-38, 13}, {-37, 13}, {-37, 13}, {-37, 13}, {-37, 13},
449
  {-36, 13}, {-36, 13}, {-36, 13}, {-36, 13}, { 42, 13}, { 42, 13}, { 42, 13}, { 42, 13},
450
  { 36, 13}, { 36, 13}, { 36, 13}, { 36, 13}, { 43, 13}, { 43, 13}, { 43, 13}, { 43, 13},
451
  { 41, 13}, { 41, 13}, { 41, 13}, { 41, 13}, { 40, 13}, { 40, 13}, { 40, 13}, { 40, 13},
452
  { 35, 13}, { 35, 13}, { 35, 13}, { 35, 13}, { 39, 13}, { 39, 13}, { 39, 13}, { 39, 13},
453
  { 38, 13}, { 38, 13}, { 38, 13}, { 38, 13}, { 37, 13}, { 37, 13}, { 37, 13}, { 37, 13}
454
};
455

    
456
/* inter mean value, codes 000000000000100101 ... 0000000000101101xx */
457
static vlc_code_t svq1_inter_mean_table_3[147] = {
458
  {111, 18}, {102, 18}, { 99, 18},
459
  {-86, 18}, { 97, 18}, {-97, 18}, { 96, 18}, {-95, 18}, {-76, 18}, {-77, 18}, {-78, 18},
460
  {-85, 18}, {-80, 18}, {-81, 18}, { 89, 18}, { 90, 18}, {-84, 18}, {-89, 18}, { 80, 18},  
461
  {-90, 18}, {-88, 18}, { 92, 18}, { 93, 18}, { 95, 18}, {-109,18}, {-79, 17}, {-79, 17},
462
  {-83, 17}, {-83, 17}, {-75, 17}, {-75, 17}, {-74, 17}, {-74, 17}, {-73, 17}, {-73, 17},
463
  {-72, 17}, {-72, 17}, { 87, 17}, { 87, 17}, { 86, 17}, { 86, 17}, { 75, 17}, { 75, 17},
464
  { 85, 17}, { 85, 17}, { 84, 17}, { 84, 17}, { 81, 17}, { 81, 17}, { 79, 17}, { 79, 17},
465
  { 74, 17}, { 74, 17}, { 72, 17}, { 72, 17}, { 82, 17}, { 82, 17}, { 78, 17}, { 78, 17},
466
  { 83, 17}, { 83, 17}, { 76, 17}, { 76, 17}, { 73, 17}, { 73, 17}, { 77, 17}, { 77, 17},
467
  { 70, 16}, { 70, 16}, { 70, 16}, { 70, 16}, { 69, 16}, { 69, 16}, { 69, 16}, { 69, 16},
468
  { 64, 16}, { 64, 16}, { 64, 16}, { 64, 16}, {-68, 16}, {-68, 16}, {-68, 16}, {-68, 16},
469
  {-66, 16}, {-66, 16}, {-66, 16}, {-66, 16}, { 68, 16}, { 68, 16}, { 68, 16}, { 68, 16},
470
  {-69, 16}, {-69, 16}, {-69, 16}, {-69, 16}, { 65, 16}, { 65, 16}, { 65, 16}, { 65, 16},
471
  { 71, 16}, { 71, 16}, { 71, 16}, { 71, 16}, {-70, 16}, {-70, 16}, {-70, 16}, {-70, 16},
472
  {-65, 16}, {-65, 16}, {-65, 16}, {-65, 16}, {-67, 16}, {-67, 16}, {-67, 16}, {-67, 16},
473
  {-63, 16}, {-63, 16}, {-63, 16}, {-63, 16}, {-71, 16}, {-71, 16}, {-71, 16}, {-71, 16},
474
  { 67, 16}, { 67, 16}, { 67, 16}, { 67, 16}, {-61, 16}, {-61, 16}, {-61, 16}, {-61, 16},
475
  {-64, 16}, {-64, 16}, {-64, 16}, {-64, 16}, { 63, 16}, { 63, 16}, { 63, 16}, { 63, 16},
476
  { 62, 16}, { 62, 16}, { 62, 16}, { 62, 16}, { 66, 16}, { 66, 16}, { 66, 16}, { 66, 16}
477
};
478

    
479
/* inter mean value, codes 00000000000001001001 ... 0000000000001001001x */
480
static vlc_code_t svq1_inter_mean_table_4[75] = {
481
  {142, 20}, {135, 20}, {125, 20}, {123, 20}, {122, 20}, {119, 20}, {117, 20},
482
  {113, 20}, {104, 20}, {103, 20}, {-120,20}, {-114,20}, {-108,20}, {-104,20}, {-102,20},
483
  {-101,20}, {-93, 20}, {-91, 19}, {-91, 19}, {-96, 19}, {-96, 19}, { 88, 19}, { 88, 19},
484
  { 91, 19}, { 91, 19}, { 94, 19}, { 94, 19}, {121, 19}, {121, 19}, {120, 19}, {120, 19},
485
  {-110,19}, {-110,19}, {118, 19}, {118, 19}, {115, 19}, {115, 19}, {114, 19}, {114, 19},
486
  {112, 19}, {112, 19}, {107, 19}, {107, 19}, {110, 19}, {110, 19}, {109, 19}, {109, 19},
487
  {108, 19}, {108, 19}, {-103,19}, {-103,19}, {106, 19}, {106, 19}, {105, 19}, {105, 19},
488
  {-100,19}, {-100,19}, {101, 19}, {101, 19}, {100, 19}, {100, 19}, {-99, 19}, {-99, 19},
489
  {-82, 19}, {-82, 19}, {-87, 19}, {-87, 19}, {-94, 19}, {-94, 19}, {-98, 19}, {-98, 19},
490
  { 98, 19}, { 98, 19}, {-92, 19}, {-92, 19}
491
};
492

    
493
/* inter mean value, codes 0000000000000000000000 ... 000000000000010010001x */
494
static vlc_code_t svq1_inter_mean_table_5[292] = {
495
  {255, 22}, {254, 22}, {253, 22}, {252, 22}, {251, 22}, {250, 22}, {249, 22}, {248, 22},
496
  {247, 22}, {246, 22}, {245, 22}, {244, 22}, {243, 22}, {242, 22}, {241, 22}, {240, 22},
497
  {239, 22}, {238, 22}, {237, 22}, {236, 22}, {235, 22}, {234, 22}, {233, 22}, {232, 22},
498
  {231, 22}, {230, 22}, {229, 22}, {228, 22}, {227, 22}, {226, 22}, {225, 22}, {224, 22},
499
  {223, 22}, {222, 22}, {221, 22}, {220, 22}, {219, 22}, {218, 22}, {217, 22}, {216, 22},
500
  {215, 22}, {214, 22}, {213, 22}, {212, 22}, {211, 22}, {210, 22}, {209, 22}, {208, 22},
501
  {207, 22}, {206, 22}, {205, 22}, {204, 22}, {203, 22}, {202, 22}, {201, 22}, {200, 22},
502
  {199, 22}, {198, 22}, {197, 22}, {196, 22}, {195, 22}, {194, 22}, {193, 22}, {192, 22},
503
  {191, 22}, {190, 22}, {189, 22}, {188, 22}, {187, 22}, {186, 22}, {185, 22}, {184, 22},
504
  {183, 22}, {182, 22}, {181, 22}, {180, 22}, {179, 22}, {178, 22}, {177, 22}, {176, 22},
505
  {175, 22}, {174, 22}, {173, 22}, {172, 22}, {171, 22}, {170, 22}, {169, 22}, {168, 22},
506
  {167, 22}, {166, 22}, {-256,22}, {164, 22}, {-211,22}, {162, 22}, {161, 22}, {160, 22},
507
  {-210,22}, {-168,22}, {157, 22}, {156, 22}, {155, 22}, {154, 22}, {153, 22}, {152, 22},
508
  {151, 22}, {150, 22}, {149, 22}, {148, 22}, {147, 22}, {146, 22}, {145, 22}, {144, 22},
509
  {143, 22}, {-208,22}, {141, 22}, {140, 22}, {139, 22}, {-200,22}, {137, 22}, {136, 22},
510
  {-198,22}, {134, 22}, {133, 22}, {-196,22}, {-201,22}, {130, 22}, {129, 22}, {128, 22},
511
  {127, 22}, {126, 22}, {-195,22}, {124, 22}, {-167,22}, {-166,22}, {-165,22}, {-164,22},
512
  {-163,22}, {-162,22}, {-161,22}, {-180,22}, {-160,22}, {-159,22}, {-158,22}, {-157,22},
513
  {-156,22}, {-155,22}, {-154,22}, {-153,22}, {-152,22}, {-151,22}, {-150,22}, {-149,22},
514
  {-148,22}, {-147,22}, {-146,22}, {-145,22}, {-144,22}, {-143,22}, {-142,22}, {-141,22},
515
  {-140,22}, {-139,22}, {-138,22}, {-137,22}, {-136,22}, {-135,22}, {-134,22}, {-133,22},
516
  {-132,22}, {-131,22}, {-130,22}, {-129,22}, {-126,22}, {-125,22}, {-124,22}, {-123,22},
517
  {-122,22}, {-121,22}, {-118,22}, {-116,22}, {-115,22}, {-113,22}, {-112,22}, {-107,22},
518
  {-106,22}, {-169,22}, {-170,22}, {-171,22}, {-172,22}, {-173,22}, {-174,22}, {-175,22},
519
  {-176,22}, {-177,22}, {-178,22}, {-187,22}, {-179,22}, {-181,22}, {-182,22}, {-183,22},
520
  {-184,22}, {-185,22}, {-186,22}, {-235,22}, {-188,22}, {-189,22}, {-190,22}, {-191,22},
521
  {-192,22}, {-193,22}, {-194,22}, {-197,22}, {-255,22}, {-254,22}, {-253,22}, {-252,22},
522
  {-251,22}, {-250,22}, {-249,22}, {-248,22}, {-247,22}, {-246,22}, {-245,22}, {-244,22},
523
  {-243,22}, {-242,22}, {-241,22}, {-240,22}, {-239,22}, {-238,22}, {-237,22}, {-232,22},
524
  {-236,22}, {-234,22}, {-233,22}, {-217,22}, {-231,22}, {-230,22}, {-229,22}, {-228,22},
525
  {-227,22}, {-226,22}, {-225,22}, {-224,22}, {-223,22}, {-222,22}, {-221,22}, {-220,22},
526
  {-219,22}, {-216,22}, {-202,22}, {-205,22}, {-215,22}, {-214,22}, {-213,22}, {-204,22},
527
  {-212,22}, {-209,22}, {-218,22}, {-199,22}, {-207,22}, {-206,22}, {165, 21}, {165, 21},
528
  {131, 21}, {131, 21}, {163, 21}, {163, 21}, {-203,21}, {-203,21}, {116, 21}, {116, 21},
529
  {159, 21}, {159, 21}, {138, 21}, {138, 21}, {158, 21}, {158, 21}, {-105,21}, {-105,21},
530
  {-111,21}, {-111,21}, {132, 21}, {132, 21}, {128, 21}, {128, 21}, {-127,21}, {-127,21},
531
  {-119,21}, {-119,21}, {-117,21}, {-117,21}
532
};
533

    
534
#define SVQ1_PROCESS_VECTOR()\
535
    for (; level > 0; i++) {\
536
      /* process next depth */\
537
      if (i == m) {\
538
        m = n;\
539
        if (--level == 0)\
540
          break;\
541
      }\
542
      /* divide block if next bit set */\
543
      if (get_bits (bitbuf, 1) == 0)\
544
        break;\
545
      /* add child nodes */\
546
      list[n++] = list[i];\
547
      list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
548
    }
549

    
550
#define SVQ1_ADD_CODEBOOK()\
551
          /* add codebook entries to vector */\
552
          for (j=0; j < stages; j++) {\
553
            n3  = codebook[entries[j]] ^ 0x80808080;\
554
            n1 += ((n3 & 0xFF00FF00) >> 8);\
555
            n2 +=  (n3 & 0x00FF00FF);\
556
          }\
557
\
558
          /* clip to [0..255] */\
559
          if (n1 & 0xFF00FF00) {\
560
            n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
561
            n1 += 0x7F007F00;\
562
            n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
563
            n1 &= (n3 & 0x00FF00FF);\
564
          }\
565
\
566
          if (n2 & 0xFF00FF00) {\
567
            n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
568
            n2 += 0x7F007F00;\
569
            n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
570
            n2 &= (n3 & 0x00FF00FF);\
571
          }
572

    
573
#define SVQ1_DO_CODEBOOK_INTRA()\
574
      for (y=0; y < height; y++) {\
575
        for (x=0; x < (width / 4); x++, codebook++) {\
576
        n1 = n4;\
577
        n2 = n4;\
578
        SVQ1_ADD_CODEBOOK()\
579
        /* store result */\
580
        dst[x] = (n1 << 8) | n2;\
581
        }\
582
        dst += (pitch / 4);\
583
      }
584

    
585
#define SVQ1_DO_CODEBOOK_NONINTRA()\
586
      for (y=0; y < height; y++) {\
587
        for (x=0; x < (width / 4); x++, codebook++) {\
588
        n3 = dst[x];\
589
        /* add mean value to vector */\
590
        n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
591
        n2 =  (n3 & 0x00FF00FF)          + n4;\
592
        SVQ1_ADD_CODEBOOK()\
593
        /* store result */\
594
        dst[x] = (n1 << 8) | n2;\
595
        }\
596
        dst += (pitch / 4);\
597
      }
598

    
599
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
600
      codebook = (const uint32_t *) cbook[level];\
601
      bit_cache = get_bits (bitbuf, 4*stages);\
602
      /* calculate codebook entries for this vector */\
603
      for (j=0; j < stages; j++) {\
604
        entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
605
      }\
606
      mean -= (stages * 128);\
607
      n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
608

    
609
static int svq1_decode_block_intra (bit_buffer_t *bitbuf, uint8_t *pixels, int pitch ) {
610
  uint32_t    bit_cache;
611
  vlc_code_t *vlc;
612
  uint8_t    *list[63];
613
  uint32_t   *dst;
614
  const uint32_t *codebook;
615
  int              entries[6];
616
  int              i, j, m, n;
617
  int              mean, stages;
618
  unsigned    x, y, width, height, level;
619
  uint32_t    n1, n2, n3, n4;
620

    
621
  /* initialize list for breadth first processing of vectors */
622
  list[0] = pixels;
623

    
624
  /* recursively process vector */
625
  for (i=0, m=1, n=1, level=5; i < n; i++) {
626
    SVQ1_PROCESS_VECTOR();
627

    
628
    /* destination address and vector size */
629
    dst = (uint32_t *) list[i];
630
    width = 1 << ((4 + level) /2);
631
    height = 1 << ((3 + level) /2);
632

    
633
    /* get number of stages (-1 skips vector, 0 for mean only) */
634
    bit_cache = get_bit_cache (bitbuf);
635

    
636
    vlc = &svq1_intra_vector_tables[level][bit_cache >> (32 - 7)];
637

    
638
    /* flush bits */
639
    stages            = vlc->value;
640
    skip_bits(bitbuf,vlc->length);
641

    
642
    if (stages == -1) {
643
        for (y=0; y < height; y++) {
644
          memset (&dst[y*(pitch / 4)], 0, width);
645
        }
646
      continue;                /* skip vector */
647
    }
648

    
649
    if ((stages > 0) && (level >= 4)) {
650
#ifdef DEBUG_SVQ1
651
    printf("Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
652
#endif
653
      return -1;        /* invalid vector */
654
    }
655

    
656
    /* get mean value for vector */
657
    bit_cache = get_bit_cache (bitbuf);
658

    
659
    if (bit_cache >= 0x25000000)
660
        vlc = &svq1_intra_mean_table_0[(bit_cache >> (32 - 8)) - 37];
661
    else if (bit_cache >= 0x03400000)
662
        vlc = &svq1_intra_mean_table_1[(bit_cache >> (32 - 10)) - 13];
663
    else if (bit_cache >= 0x00040000) 
664
        vlc = &svq1_intra_mean_table_2[(bit_cache >> (32 - 14)) - 1];
665
    else
666
        vlc = &svq1_intra_mean_table_3[bit_cache >> (32 - 20)];
667

    
668
    /* flush bits */
669
    mean            = vlc->value;
670
    skip_bits(bitbuf,vlc->length);
671

    
672
    if (stages == 0) {
673
      for (y=0; y < height; y++) {
674
        memset (&dst[y*(pitch / 4)], mean, width);
675
      }
676
    } else {
677
      SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
678
      SVQ1_DO_CODEBOOK_INTRA()
679
    }
680
  }
681

    
682
  return 0;
683
}
684

    
685
static int svq1_decode_block_non_intra (bit_buffer_t *bitbuf, uint8_t *pixels, int pitch ) {
686
  uint32_t    bit_cache;
687
  vlc_code_t *vlc;
688
  uint8_t    *list[63];
689
  uint32_t   *dst;
690
  const uint32_t *codebook;
691
  int              entries[6];
692
  int              i, j, m, n;
693
  int              mean, stages;
694
  int              x, y, width, height, level;
695
  uint32_t    n1, n2, n3, n4;
696

    
697
  /* initialize list for breadth first processing of vectors */
698
  list[0] = pixels;
699

    
700
  /* recursively process vector */
701
  for (i=0, m=1, n=1, level=5; i < n; i++) {
702
    SVQ1_PROCESS_VECTOR();
703

    
704
    /* destination address and vector size */
705
    dst = (uint32_t *) list[i];
706
    width = 1 << ((4 + level) /2);
707
    height = 1 << ((3 + level) /2);
708

    
709
    /* get number of stages (-1 skips vector, 0 for mean only) */
710
    bit_cache = get_bit_cache (bitbuf);
711

    
712
    vlc = &svq1_inter_vector_tables[level][bit_cache >> (32 - 6)];
713

    
714
    /* flush bits */
715
    stages            = vlc->value;
716
    skip_bits(bitbuf,vlc->length);
717

    
718
    if (stages == -1) continue;        /* skip vector */
719

    
720
    if ((stages > 0) && (level >= 4)) {
721
#ifdef DEBUG_SVQ1
722
    printf("Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
723
#endif
724
      return -1;        /* invalid vector */
725
    }
726

    
727
    /* get mean value for vector */
728
    bit_cache = get_bit_cache (bitbuf);
729

    
730
    if (bit_cache >= 0x0B000000)
731
        vlc = &svq1_inter_mean_table_0[(bit_cache >> (32 - 8)) - 11];
732
    else if (bit_cache >= 0x01200000)
733
        vlc = &svq1_inter_mean_table_1[(bit_cache >> (32 - 12)) - 18];
734
    else if (bit_cache >= 0x002E0000) 
735
        vlc = &svq1_inter_mean_table_2[(bit_cache >> (32 - 15)) - 23];
736
    else if (bit_cache >= 0x00094000)
737
        vlc = &svq1_inter_mean_table_3[(bit_cache >> (32 - 18)) - 37];
738
    else if (bit_cache >= 0x00049000)
739
        vlc = &svq1_inter_mean_table_4[(bit_cache >> (32 - 20)) - 73];
740
    else
741
        vlc = &svq1_inter_mean_table_5[bit_cache >> (32 - 22)];
742

    
743
    /* flush bits */
744
    mean            = vlc->value;
745
    skip_bits(bitbuf,vlc->length);
746

    
747
    SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
748
    SVQ1_DO_CODEBOOK_NONINTRA()
749
  }
750
  return 0;
751
}
752

    
753
static int svq1_decode_motion_vector (bit_buffer_t *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
754
  uint32_t    bit_cache;
755
  vlc_code_t *vlc;
756
  int              diff, sign;
757
  int              i;
758

    
759
  for (i=0; i < 2; i++) {
760

    
761
    /* get motion code */
762
    bit_cache = get_bit_cache (bitbuf);
763

    
764
    if (!(bit_cache & 0xFFE00000))
765
      return -1;        /* invalid vlc code */
766

    
767
    if (bit_cache & 0x80000000) {
768
      diff = 0;
769

    
770
      /* flush bit */
771
      skip_bits(bitbuf,1);
772

    
773
    } else {
774
      if (bit_cache >= 0x06000000) {
775
        vlc = &svq1_motion_table_0[(bit_cache >> (32 - 7)) - 3];
776
      } else {
777
        vlc = &svq1_motion_table_1[(bit_cache >> (32 - 12)) - 2];
778
      }
779

    
780
      /* decode motion vector differential */
781
      sign = (int) (bit_cache << (vlc->length - 1)) >> 31;
782
      diff = (vlc->value ^ sign) - sign;
783

    
784
      /* flush bits */
785
      skip_bits(bitbuf,vlc->length);
786
    }
787

    
788
    /* add median of motion vector predictors and clip result */
789
    if (i == 1)
790
      mv->y = ((diff + MEDIAN(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
791
    else
792
      mv->x = ((diff + MEDIAN(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
793
  }
794

    
795
  return 0;
796
}
797

    
798
static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
799
  uint8_t *src;
800
  uint8_t *dst;
801
  int           i;
802

    
803
  src = &previous[x + y*pitch];
804
  dst = current;
805

    
806
  for (i=0; i < 16; i++) {
807
    memcpy (dst, src, 16);
808
    src += pitch;
809
    dst += pitch;
810
  }
811
}
812

    
813
static int svq1_motion_inter_block (MpegEncContext *s, bit_buffer_t *bitbuf,
814
                               uint8_t *current, uint8_t *previous, int pitch,
815
                               svq1_pmv_t *motion, int x, int y) {
816
  uint8_t    *src;
817
  uint8_t    *dst;
818
  svq1_pmv_t  mv;
819
  svq1_pmv_t *pmv[3];
820
  int              result;
821

    
822
  /* predict and decode motion vector */
823
  pmv[0] = &motion[0];
824
  if (y == 0) {
825
    pmv[1] =
826
    pmv[2] = pmv[0];
827
  }
828
  else {
829
    pmv[1] = &motion[(x / 8) + 2];
830
    pmv[2] = &motion[(x / 8) + 4];
831
  }
832

    
833
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
834

    
835
  if (result != 0)
836
    return result;
837

    
838
  motion[0].x                =
839
  motion[(x / 8) + 2].x        =
840
  motion[(x / 8) + 3].x        = mv.x;
841
  motion[0].y                =
842
  motion[(x / 8) + 2].y        =
843
  motion[(x / 8) + 3].y        = mv.y;
844
  
845
  if(y + (mv.y >> 1)<0)
846
     mv.y= 0;
847
  if(x + (mv.x >> 1)<0)
848
     mv.x= 0;
849

    
850
#if 0
851
  int w= (s->width+15)&~15;
852
  int h= (s->height+15)&~15;
853
  if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
854
      printf("%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
855
#endif
856
 
857
  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
858
  dst = current;
859

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

    
862
  return 0;
863
}
864

    
865
static int svq1_motion_inter_4v_block (MpegEncContext *s, bit_buffer_t *bitbuf,
866
                                  uint8_t *current, uint8_t *previous, int pitch,
867
                                  svq1_pmv_t *motion,int x, int y) {
868
  uint8_t    *src;
869
  uint8_t    *dst;
870
  svq1_pmv_t  mv;
871
  svq1_pmv_t *pmv[4];
872
  int              i, result;
873

    
874
  /* predict and decode motion vector (0) */
875
  pmv[0] = &motion[0];
876
  if (y == 0) {
877
    pmv[1] =
878
    pmv[2] = pmv[0];
879
  }
880
  else {
881
    pmv[1] = &motion[(x / 8) + 2];
882
    pmv[2] = &motion[(x / 8) + 4];
883
  }
884

    
885
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
886

    
887
  if (result != 0)
888
    return result;
889

    
890
  /* predict and decode motion vector (1) */
891
  pmv[0] = &mv;
892
  if (y == 0) {
893
    pmv[1] =
894
    pmv[2] = pmv[0];
895
  }
896
  else {
897
    pmv[1] = &motion[(x / 8) + 3];
898
  }
899
  result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
900

    
901
  if (result != 0)
902
    return result;
903

    
904
  /* predict and decode motion vector (2) */
905
  pmv[1] = &motion[0];
906
  pmv[2] = &motion[(x / 8) + 1];
907

    
908
  result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
909

    
910
  if (result != 0)
911
    return result;
912

    
913
  /* predict and decode motion vector (3) */
914
  pmv[2] = &motion[(x / 8) + 2];
915
  pmv[3] = &motion[(x / 8) + 3];
916

    
917
  result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
918

    
919
  if (result != 0)
920
    return result;
921

    
922
  /* form predictions */
923
  for (i=0; i < 4; i++) {
924
    int mvx= pmv[i]->x + (i&1)*16;
925
    int mvy= pmv[i]->y + (i>>1)*16;
926
  
927
    ///XXX /FIXME cliping or padding?
928
    if(y + (mvy >> 1)<0)
929
       mvy= 0;
930
    if(x + (mvx >> 1)<0)
931
       mvx= 0;
932

    
933
#if 0
934
  int w= (s->width+15)&~15;
935
  int h= (s->height+15)&~15;
936
  if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
937
      printf("%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
938
#endif
939
    src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
940
    dst = current;
941
    
942
    s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
943

    
944
    /* select next block */
945
    if (i & 1) {
946
      current  += 8*(pitch - 1);
947
    } else {
948
      current  += 8;
949
    }
950
  }
951

    
952
  return 0;
953
}
954

    
955
static int svq1_decode_delta_block (MpegEncContext *s, bit_buffer_t *bitbuf,
956
                        uint8_t *current, uint8_t *previous, int pitch,
957
                        svq1_pmv_t *motion, int x, int y) {
958
  uint32_t bit_cache;
959
  uint32_t block_type;
960
  int           result = 0;
961

    
962
  /* get block type */
963
  bit_cache = get_bit_cache (bitbuf);
964

    
965
  bit_cache        >>= (32 - 3);
966
  block_type          = svq1_block_type_table[bit_cache].value;
967
  skip_bits(bitbuf,svq1_block_type_table[bit_cache].length);
968

    
969
  /* reset motion vectors */
970
  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
971
    motion[0].x                  =
972
    motion[0].y                  =
973
    motion[(x / 8) + 2].x =
974
    motion[(x / 8) + 2].y =
975
    motion[(x / 8) + 3].x =
976
    motion[(x / 8) + 3].y = 0;
977
  }
978

    
979
  switch (block_type) {
980
  case SVQ1_BLOCK_SKIP:
981
    svq1_skip_block (current, previous, pitch, x, y);
982
    break;
983

    
984
  case SVQ1_BLOCK_INTER:
985
    result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
986

    
987
    if (result != 0)
988
    {
989
#ifdef DEBUG_SVQ1
990
    printf("Error in svq1_motion_inter_block %i\n",result);
991
#endif
992
      break;
993
    }
994
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
995
    break;
996

    
997
  case SVQ1_BLOCK_INTER_4V:
998
    result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
999

    
1000
    if (result != 0)
1001
    {
1002
#ifdef DEBUG_SVQ1
1003
    printf("Error in svq1_motion_inter_4v_block %i\n",result);
1004
#endif
1005
      break;
1006
    }
1007
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
1008
    break;
1009

    
1010
  case SVQ1_BLOCK_INTRA:
1011
    result = svq1_decode_block_intra (bitbuf, current, pitch);
1012
    break;
1013
  }
1014

    
1015
  return result;
1016
}
1017

    
1018
/* standard video sizes */
1019
static struct { int width; int height; } svq1_frame_size_table[8] = {
1020
  { 160, 120 }, { 128,  96 }, { 176, 144 }, { 352, 288 },
1021
  { 704, 576 }, { 240, 180 }, { 320, 240 }, {  -1,  -1 }
1022
};
1023

    
1024
static int svq1_decode_frame_header (bit_buffer_t *bitbuf,MpegEncContext *s) {
1025
  int frame_size_code;
1026

    
1027
  /* unknown field */
1028
  get_bits (bitbuf, 8);
1029

    
1030
  /* frame type */
1031
  s->pict_type= get_bits (bitbuf, 2)+1;
1032
  if(s->pict_type==4) 
1033
      return -1;
1034
      
1035
  if (s->pict_type == I_TYPE) {
1036

    
1037
    /* unknown fields */
1038
    if (s->f_code == 0x50 || s->f_code == 0x60) {
1039
      get_bits (bitbuf, 16);
1040
    }
1041

    
1042
    if ((s->f_code ^ 0x10) >= 0x50) {
1043
      skip_bits(bitbuf,8*get_bits (bitbuf, 8));
1044
    }
1045

    
1046
    get_bits (bitbuf, 2);
1047
    get_bits (bitbuf, 2);
1048
    get_bits (bitbuf, 1);
1049

    
1050
    /* load frame size */
1051
    frame_size_code = get_bits (bitbuf, 3);
1052

    
1053
    if (frame_size_code == 7) {
1054
      /* load width, height (12 bits each) */
1055
      s->width = get_bits (bitbuf, 12);
1056
      s->height = get_bits (bitbuf, 12);
1057

    
1058
      if (!s->width || !s->height)
1059
        return -1;
1060
    } else {
1061
      /* get width, height from table */
1062
      s->width = svq1_frame_size_table[frame_size_code].width;
1063
      s->height = svq1_frame_size_table[frame_size_code].height;
1064
    }
1065
  }
1066

    
1067
  /* unknown fields */
1068
  if (get_bits (bitbuf, 1) == 1) {
1069
    get_bits (bitbuf, 1);
1070
    get_bits (bitbuf, 1);
1071

    
1072
    if (get_bits (bitbuf, 2) != 0)
1073
      return -1;
1074
  }
1075

    
1076
  if (get_bits (bitbuf, 1) == 1) {
1077
    get_bits (bitbuf, 1);
1078
    get_bits (bitbuf, 4);
1079
    get_bits (bitbuf, 1);
1080
    get_bits (bitbuf, 2);
1081

    
1082
    while (get_bits (bitbuf, 1) == 1) {
1083
      get_bits (bitbuf, 8);
1084
    }
1085
  }
1086
  
1087
  return 0;
1088
}
1089

    
1090
static int svq1_decode_frame(AVCodecContext *avctx, 
1091
                             void *data, int *data_size,
1092
                             uint8_t *buf, int buf_size)
1093
{
1094
  MpegEncContext *s=avctx->priv_data;
1095
  uint8_t      *current, *previous;
1096
  int                result, i, x, y, width, height;
1097
  AVFrame *pict = data; 
1098

    
1099
  /* initialize bit buffer */
1100
  init_get_bits(&s->gb,buf,buf_size*8);
1101

    
1102
  /* decode frame header */
1103
  s->f_code = get_bits (&s->gb, 22);
1104

    
1105
  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
1106
    return -1;
1107

    
1108
  /* swap some header bytes (why?) */
1109
  if (s->f_code != 0x20) {
1110
    uint32_t *src = (uint32_t *) (buf + 4);
1111

    
1112
    for (i=0; i < 4; i++) {
1113
      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
1114
    }
1115
  }
1116

    
1117
  result = svq1_decode_frame_header (&s->gb, s);
1118

    
1119
  if (result != 0)
1120
  {
1121
#ifdef DEBUG_SVQ1
1122
    printf("Error in svq1_decode_frame_header %i\n",result);
1123
#endif
1124
    return result;
1125
  }
1126
  
1127
  //FIXME this avoids some confusion for "B frames" without 2 references
1128
  //this should be removed after libavcodec can handle more flaxible picture types & ordering
1129
  if(s->pict_type==B_TYPE && s->last_picture.data[0]==NULL) return buf_size;
1130
  
1131
  if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
1132

    
1133
  if(MPV_frame_start(s, avctx) < 0)
1134
      return -1;
1135

    
1136
  /* decode y, u and v components */
1137
  for (i=0; i < 3; i++) {
1138
    int linesize;
1139
    if (i == 0) {
1140
      width  = (s->width+15)&~15;
1141
      height = (s->height+15)&~15;
1142
      linesize= s->linesize;
1143
    } else {
1144
      if(s->flags&CODEC_FLAG_GRAY) break;
1145
      width  = (s->width/4+15)&~15;
1146
      height = (s->height/4+15)&~15;
1147
      linesize= s->uvlinesize;
1148
    }
1149

    
1150
    current  = s->current_picture.data[i];
1151

    
1152
    if(s->pict_type==B_TYPE){
1153
        previous = s->next_picture.data[i];
1154
    }else{
1155
        previous = s->last_picture.data[i];
1156
    }
1157

    
1158
    if (s->pict_type == I_TYPE) {
1159
      /* keyframe */
1160
      for (y=0; y < height; y+=16) {
1161
        for (x=0; x < width; x+=16) {
1162
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
1163
          if (result != 0)
1164
          {
1165
#ifdef DEBUG_SVQ1
1166
            printf("Error in svq1_decode_block %i (keyframe)\n",result);
1167
#endif
1168
            return result;
1169
          }
1170
        }
1171
        current += 16*linesize;
1172
      }
1173
    } else {
1174
      svq1_pmv_t pmv[width/8+3];
1175
      /* delta frame */
1176
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
1177

    
1178
      for (y=0; y < height; y+=16) {
1179
        for (x=0; x < width; x+=16) {
1180
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
1181
                                            linesize, pmv, x, y);
1182
          if (result != 0)
1183
          {
1184
#ifdef DEBUG_SVQ1
1185
    printf("Error in svq1_decode_delta_block %i\n",result);
1186
#endif
1187
            return result;
1188
          }
1189
        }
1190

    
1191
        pmv[0].x =
1192
        pmv[0].y = 0;
1193

    
1194
        current += 16*linesize;
1195
      }
1196
    }
1197
  }
1198
  
1199
  *pict = *(AVFrame*)&s->current_picture;
1200

    
1201

    
1202
  MPV_frame_end(s);
1203
  
1204
  *data_size=sizeof(AVFrame);
1205
  return buf_size;
1206
}
1207

    
1208
static int svq1_decode_init(AVCodecContext *avctx)
1209
{
1210
    MpegEncContext *s = avctx->priv_data;
1211

    
1212
    s->avctx = avctx;
1213
    s->width = (avctx->width+3)&~3;
1214
    s->height = (avctx->height+3)&~3;
1215
    s->codec_id= avctx->codec->id;
1216
    avctx->pix_fmt = PIX_FMT_YUV410P;
1217
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
1218
    s->flags= avctx->flags;
1219
    if (MPV_common_init(s) < 0) return -1;
1220
    return 0;
1221
}
1222

    
1223
static int svq1_decode_end(AVCodecContext *avctx)
1224
{
1225
    MpegEncContext *s = avctx->priv_data;
1226

    
1227
    MPV_common_end(s);
1228
    return 0;
1229
}
1230

    
1231
AVCodec svq1_decoder = {
1232
    "svq1",
1233
    CODEC_TYPE_VIDEO,
1234
    CODEC_ID_SVQ1,
1235
    sizeof(MpegEncContext),
1236
    svq1_decode_init,
1237
    NULL,
1238
    svq1_decode_end,
1239
    svq1_decode_frame,
1240
    CODEC_CAP_DR1,
1241
};