## ffmpeg / libavcodec / svq1.c @ 186447f8

History | View | Annotate | Download (22.9 KB)

1 | 36577721 | Nick Kurshev | ```
/*
``` |
---|---|---|---|

2 | ```
*
``` |
||

3 | be8ffec9 | Nick Kurshev | ```
* Copyright (C) 2002 the xine project
``` |

4 | 36577721 | Nick Kurshev | ```
* Copyright (C) 2002 the ffmpeg project
``` |

5 | be8ffec9 | Nick Kurshev | ```
*
``` |

6 | 36577721 | Nick Kurshev | ```
* 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 | 861dfbb5 | Nick Kurshev | ```
* Ported to mplayer by Arpi <arpi@thot.banki.hu>
``` |

21 | be8ffec9 | Nick Kurshev | ```
* Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
``` |

22 | ```
*
``` |
||

23 | ```
*/
``` |
||

24 | 983e3246 | Michael Niedermayer | |

25 | ```
/**
``` |
||

26 | ```
* @file svq1.c
``` |
||

27 | 59fcece9 | Mike Melanson | ```
* Sorenson Vector Quantizer #1 (SVQ1) video decoder.
``` |

28 | 983e3246 | Michael Niedermayer | ```
*/
``` |

29 | |||

30 | 59fcece9 | Mike Melanson | |

31 | be8ffec9 | Nick Kurshev | ```
//#define DEBUG_SVQ1
``` |

32 | #include <stdio.h> |
||

33 | #include <stdlib.h> |
||

34 | #include <string.h> |
||

35 | #include <unistd.h> |
||

36 | |||

37 | 82dd7d0d | Nick Kurshev | #include "common.h" |

38 | be8ffec9 | Nick Kurshev | #include "avcodec.h" |

39 | #include "dsputil.h" |
||

40 | #include "mpegvideo.h" |
||

41 | 59fcece9 | Mike Melanson | #include "bswap.h" |

42 | be8ffec9 | Nick Kurshev | |

43 | 59fcece9 | Mike Melanson | ```
static VLC svq1_block_type;
``` |

44 | ```
static VLC svq1_motion_component;
``` |
||

45 | static VLC svq1_intra_multistage[6]; |
||

46 | static VLC svq1_inter_multistage[6]; |
||

47 | ```
static VLC svq1_intra_mean;
``` |
||

48 | ```
static VLC svq1_inter_mean;
``` |
||

49 | be8ffec9 | Nick Kurshev | |

50 | 63e0d4ac | Nick Kurshev | ```
#define MEDIAN(a,b,c) (((a < b) != (b >= c)) ? b : (((a < c) != (c > b)) ? c : a))
``` |

51 | be8ffec9 | Nick Kurshev | |

52 | #define SVQ1_BLOCK_SKIP 0 |
||

53 | #define SVQ1_BLOCK_INTER 1 |
||

54 | #define SVQ1_BLOCK_INTER_4V 2 |
||

55 | #define SVQ1_BLOCK_INTRA 3 |
||

56 | |||

57 | ```
/* motion vector (prediction) */
``` |
||

58 | typedef struct svq1_pmv_s { |
||

59 | ```
int x;
``` |
||

60 | ```
int y;
``` |
||

61 | } svq1_pmv_t; |
||

62 | |||

63 | ce23c668 | Alex Beregszaszi | #include "svq1_cb.h" |

64 | 59fcece9 | Mike Melanson | #include "svq1_vlc.h" |

65 | |||

66 | static const uint16_t checksum_table[256] = { |
||

67 | 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, |
||

68 | 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, |
||

69 | 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, |
||

70 | 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, |
||

71 | 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, |
||

72 | 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, |
||

73 | 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, |
||

74 | 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, |
||

75 | 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, |
||

76 | 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, |
||

77 | 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, |
||

78 | 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, |
||

79 | 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, |
||

80 | 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, |
||

81 | 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, |
||

82 | 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, |
||

83 | 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, |
||

84 | 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, |
||

85 | 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, |
||

86 | 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, |
||

87 | 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, |
||

88 | 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, |
||

89 | 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, |
||

90 | 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, |
||

91 | 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, |
||

92 | 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, |
||

93 | 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, |
||

94 | 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, |
||

95 | 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, |
||

96 | 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, |
||

97 | 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, |
||

98 | 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 |
||

99 | be8ffec9 | Nick Kurshev | }; |

100 | |||

101 | 59fcece9 | Mike Melanson | static const uint8_t string_table[256] = { |

102 | 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54, |
||

103 | 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D, |
||

104 | 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06, |
||

105 | 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F, |
||

106 | 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0, |
||

107 | 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9, |
||

108 | 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2, |
||

109 | 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B, |
||

110 | 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9, |
||

111 | 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0, |
||

112 | 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B, |
||

113 | 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2, |
||

114 | 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D, |
||

115 | 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44, |
||

116 | 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F, |
||

117 | 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16, |
||

118 | 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB, |
||

119 | 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92, |
||

120 | 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9, |
||

121 | 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0, |
||

122 | 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F, |
||

123 | 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36, |
||

124 | 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D, |
||

125 | 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64, |
||

126 | 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26, |
||

127 | 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F, |
||

128 | 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74, |
||

129 | 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D, |
||

130 | 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82, |
||

131 | 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB, |
||

132 | 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0, |
||

133 | 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9 |
||

134 | be8ffec9 | Nick Kurshev | }; |

135 | |||

136 | 82dd7d0d | Nick Kurshev | ```
#define SVQ1_PROCESS_VECTOR()\
``` |

137 | for (; level > 0; i++) {\ |
||

138 | ```
/* process next depth */\
``` |
||

139 | ```
if (i == m) {\
``` |
||

140 | m = n;\ |
||

141 | if (--level == 0)\ |
||

142 | ```
break;\
``` |
||

143 | }\ |
||

144 | ```
/* divide block if next bit set */\
``` |
||

145 | if (get_bits (bitbuf, 1) == 0)\ |
||

146 | ```
break;\
``` |
||

147 | ```
/* add child nodes */\
``` |
||

148 | list[n++] = list[i];\ |
||

149 | list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\ |
||

150 | } |
||

151 | |||

152 | ```
#define SVQ1_ADD_CODEBOOK()\
``` |
||

153 | ```
/* add codebook entries to vector */\
``` |
||

154 | for (j=0; j < stages; j++) {\ |
||

155 | ```
n3 = codebook[entries[j]] ^ 0x80808080;\
``` |
||

156 | n1 += ((n3 & 0xFF00FF00) >> 8);\ |
||

157 | ```
n2 += (n3 & 0x00FF00FF);\
``` |
||

158 | }\ |
||

159 | \ |
||

160 | ```
/* clip to [0..255] */\
``` |
||

161 | if (n1 & 0xFF00FF00) {\ |
||

162 | n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ |
||

163 | ```
n1 += 0x7F007F00;\
``` |
||

164 | n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ |
||

165 | ```
n1 &= (n3 & 0x00FF00FF);\
``` |
||

166 | }\ |
||

167 | \ |
||

168 | if (n2 & 0xFF00FF00) {\ |
||

169 | n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ |
||

170 | ```
n2 += 0x7F007F00;\
``` |
||

171 | n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ |
||

172 | ```
n2 &= (n3 & 0x00FF00FF);\
``` |
||

173 | } |
||

174 | be8ffec9 | Nick Kurshev | |

175 | 82dd7d0d | Nick Kurshev | ```
#define SVQ1_DO_CODEBOOK_INTRA()\
``` |

176 | for (y=0; y < height; y++) {\ |
||

177 | for (x=0; x < (width / 4); x++, codebook++) {\ |
||

178 | n1 = n4;\ |
||

179 | n2 = n4;\ |
||

180 | SVQ1_ADD_CODEBOOK()\ |
||

181 | ```
/* store result */\
``` |
||

182 | ```
dst[x] = (n1 << 8) | n2;\
``` |
||

183 | }\ |
||

184 | ```
dst += (pitch / 4);\
``` |
||

185 | } |
||

186 | |||

187 | ```
#define SVQ1_DO_CODEBOOK_NONINTRA()\
``` |
||

188 | for (y=0; y < height; y++) {\ |
||

189 | for (x=0; x < (width / 4); x++, codebook++) {\ |
||

190 | n3 = dst[x];\ |
||

191 | ```
/* add mean value to vector */\
``` |
||

192 | n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\ |
||

193 | ```
n2 = (n3 & 0x00FF00FF) + n4;\
``` |
||

194 | SVQ1_ADD_CODEBOOK()\ |
||

195 | ```
/* store result */\
``` |
||

196 | ```
dst[x] = (n1 << 8) | n2;\
``` |
||

197 | }\ |
||

198 | ```
dst += (pitch / 4);\
``` |
||

199 | } |
||

200 | |||

201 | ```
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
``` |
||

202 | 18f77016 | Zdenek Kabelac | ```
codebook = (const uint32_t *) cbook[level];\
``` |

203 | 82dd7d0d | Nick Kurshev | ```
bit_cache = get_bits (bitbuf, 4*stages);\
``` |

204 | ```
/* calculate codebook entries for this vector */\
``` |
||

205 | for (j=0; j < stages; j++) {\ |
||

206 | entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\ |
||

207 | }\ |
||

208 | ```
mean -= (stages * 128);\
``` |
||

209 | n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF); |
||

210 | be8ffec9 | Nick Kurshev | |

211 | 59fcece9 | Mike Melanson | static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { |

212 | be8ffec9 | Nick Kurshev | uint32_t bit_cache; |

213 | ```
uint8_t *list[63];
``` |
||

214 | uint32_t *dst; |
||

215 | 18f77016 | Zdenek Kabelac | ```
const uint32_t *codebook;
``` |

216 | be8ffec9 | Nick Kurshev | int entries[6]; |

217 | ```
int i, j, m, n;
``` |
||

218 | ```
int mean, stages;
``` |
||

219 | 18f77016 | Zdenek Kabelac | ```
unsigned x, y, width, height, level;
``` |

220 | be8ffec9 | Nick Kurshev | uint32_t n1, n2, n3, n4; |

221 | |||

222 | ```
/* initialize list for breadth first processing of vectors */
``` |
||

223 | ```
list[0] = pixels;
``` |
||

224 | |||

225 | ```
/* recursively process vector */
``` |
||

226 | for (i=0, m=1, n=1, level=5; i < n; i++) { |
||

227 | 82dd7d0d | Nick Kurshev | SVQ1_PROCESS_VECTOR(); |

228 | be8ffec9 | Nick Kurshev | |

229 | ```
/* destination address and vector size */
``` |
||

230 | dst = (uint32_t *) list[i]; |
||

231 | width = 1 << ((4 + level) /2); |
||

232 | height = 1 << ((3 + level) /2); |
||

233 | |||

234 | ```
/* get number of stages (-1 skips vector, 0 for mean only) */
``` |
||

235 | 59fcece9 | Mike Melanson | stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1; |

236 | be8ffec9 | Nick Kurshev | |

237 | if (stages == -1) { |
||

238 | for (y=0; y < height; y++) { |
||

239 | memset (&dst[y*(pitch / 4)], 0, width); |
||

240 | } |
||

241 | continue; /* skip vector */ |
||

242 | } |
||

243 | |||

244 | if ((stages > 0) && (level >= 4)) { |
||

245 | ```
#ifdef DEBUG_SVQ1
``` |
||

246 | 82dd7d0d | Nick Kurshev | ```
printf("Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
``` |

247 | be8ffec9 | Nick Kurshev | ```
#endif
``` |

248 | return -1; /* invalid vector */ |
||

249 | } |
||

250 | |||

251 | 59fcece9 | Mike Melanson | mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3); |

252 | be8ffec9 | Nick Kurshev | |

253 | 82dd7d0d | Nick Kurshev | if (stages == 0) { |

254 | be8ffec9 | Nick Kurshev | for (y=0; y < height; y++) { |

255 | ```
memset (&dst[y*(pitch / 4)], mean, width);
``` |
||

256 | } |
||

257 | ```
} else {
``` |
||

258 | 82dd7d0d | Nick Kurshev | SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks); |

259 | SVQ1_DO_CODEBOOK_INTRA() |
||

260 | } |
||

261 | } |
||

262 | be8ffec9 | Nick Kurshev | |

263 | 82dd7d0d | Nick Kurshev | return 0; |

264 | } |
||

265 | be8ffec9 | Nick Kurshev | |

266 | 59fcece9 | Mike Melanson | static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { |

267 | 82dd7d0d | Nick Kurshev | uint32_t bit_cache; |

268 | ```
uint8_t *list[63];
``` |
||

269 | uint32_t *dst; |
||

270 | 18f77016 | Zdenek Kabelac | ```
const uint32_t *codebook;
``` |

271 | 82dd7d0d | Nick Kurshev | int entries[6]; |

272 | ```
int i, j, m, n;
``` |
||

273 | ```
int mean, stages;
``` |
||

274 | ```
int x, y, width, height, level;
``` |
||

275 | uint32_t n1, n2, n3, n4; |
||

276 | be8ffec9 | Nick Kurshev | |

277 | 82dd7d0d | Nick Kurshev | ```
/* initialize list for breadth first processing of vectors */
``` |

278 | ```
list[0] = pixels;
``` |
||

279 | be8ffec9 | Nick Kurshev | |

280 | 82dd7d0d | Nick Kurshev | ```
/* recursively process vector */
``` |

281 | for (i=0, m=1, n=1, level=5; i < n; i++) { |
||

282 | SVQ1_PROCESS_VECTOR(); |
||

283 | be8ffec9 | Nick Kurshev | |

284 | 82dd7d0d | Nick Kurshev | ```
/* destination address and vector size */
``` |

285 | dst = (uint32_t *) list[i]; |
||

286 | width = 1 << ((4 + level) /2); |
||

287 | height = 1 << ((3 + level) /2); |
||

288 | be8ffec9 | Nick Kurshev | |

289 | 82dd7d0d | Nick Kurshev | ```
/* get number of stages (-1 skips vector, 0 for mean only) */
``` |

290 | 59fcece9 | Mike Melanson | stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1; |

291 | 82dd7d0d | Nick Kurshev | |

292 | if (stages == -1) continue; /* skip vector */ |
||

293 | |||

294 | if ((stages > 0) && (level >= 4)) { |
||

295 | ```
#ifdef DEBUG_SVQ1
``` |
||

296 | ```
printf("Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
``` |
||

297 | ```
#endif
``` |
||

298 | return -1; /* invalid vector */ |
||

299 | be8ffec9 | Nick Kurshev | } |

300 | |||

301 | 59fcece9 | Mike Melanson | mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256; |

302 | 82dd7d0d | Nick Kurshev | |

303 | SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks); |
||

304 | SVQ1_DO_CODEBOOK_NONINTRA() |
||

305 | } |
||

306 | be8ffec9 | Nick Kurshev | return 0; |

307 | } |
||

308 | |||

309 | 59fcece9 | Mike Melanson | static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) { |

310 | ```
int diff;
``` |
||

311 | be8ffec9 | Nick Kurshev | ```
int i;
``` |

312 | |||

313 | for (i=0; i < 2; i++) { |
||

314 | |||

315 | ```
/* get motion code */
``` |
||

316 | 59fcece9 | Mike Melanson | diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2) - 32; |

317 | be8ffec9 | Nick Kurshev | |

318 | ```
/* add median of motion vector predictors and clip result */
``` |
||

319 | if (i == 1) |
||

320 | mv->y = ((diff + MEDIAN(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26; |
||

321 | ```
else
``` |
||

322 | mv->x = ((diff + MEDIAN(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26; |
||

323 | } |
||

324 | |||

325 | return 0; |
||

326 | } |
||

327 | |||

328 | 82dd7d0d | Nick Kurshev | static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) { |

329 | be8ffec9 | Nick Kurshev | uint8_t *src; |

330 | uint8_t *dst; |
||

331 | ```
int i;
``` |
||

332 | |||

333 | src = &previous[x + y*pitch]; |
||

334 | dst = current; |
||

335 | |||

336 | for (i=0; i < 16; i++) { |
||

337 | ```
memcpy (dst, src, 16);
``` |
||

338 | src += pitch; |
||

339 | dst += pitch; |
||

340 | } |
||

341 | } |
||

342 | |||

343 | 59fcece9 | Mike Melanson | static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf, |

344 | be8ffec9 | Nick Kurshev | ```
uint8_t *current, uint8_t *previous, int pitch,
``` |

345 | svq1_pmv_t *motion, int x, int y) { |
||

346 | uint8_t *src; |
||

347 | uint8_t *dst; |
||

348 | svq1_pmv_t mv; |
||

349 | ```
svq1_pmv_t *pmv[3];
``` |
||

350 | ```
int result;
``` |
||

351 | |||

352 | ```
/* predict and decode motion vector */
``` |
||

353 | pmv[0] = &motion[0]; |
||

354 | if (y == 0) { |
||

355 | 82dd7d0d | Nick Kurshev | ```
pmv[1] =
``` |

356 | be8ffec9 | Nick Kurshev | pmv[2] = pmv[0]; |

357 | } |
||

358 | 82dd7d0d | Nick Kurshev | ```
else {
``` |

359 | pmv[1] = &motion[(x / 8) + 2]; |
||

360 | pmv[2] = &motion[(x / 8) + 4]; |
||

361 | } |
||

362 | be8ffec9 | Nick Kurshev | |

363 | 82dd7d0d | Nick Kurshev | result = svq1_decode_motion_vector (bitbuf, &mv, pmv); |

364 | be8ffec9 | Nick Kurshev | |

365 | if (result != 0) |
||

366 | ```
return result;
``` |
||

367 | |||

368 | 82dd7d0d | Nick Kurshev | ```
motion[0].x =
``` |

369 | motion[(x / 8) + 2].x = |
||

370 | be8ffec9 | Nick Kurshev | motion[(x / 8) + 3].x = mv.x; |

371 | 82dd7d0d | Nick Kurshev | ```
motion[0].y =
``` |

372 | motion[(x / 8) + 2].y = |
||

373 | be8ffec9 | Nick Kurshev | motion[(x / 8) + 3].y = mv.y; |

374 | b739d676 | Michael Niedermayer | |

375 | if(y + (mv.y >> 1)<0) |
||

376 | ```
mv.y= 0;
``` |
||

377 | if(x + (mv.x >> 1)<0) |
||

378 | ```
mv.x= 0;
``` |
||

379 | |||

380 | ```
#if 0
``` |
||

381 | ```
int w= (s->width+15)&~15;
``` |
||

382 | ```
int h= (s->height+15)&~15;
``` |
||

383 | ```
if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
``` |
||

384 | ```
printf("%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
``` |
||

385 | ```
#endif
``` |
||

386 | |||

387 | be8ffec9 | Nick Kurshev | src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch]; |

388 | dst = current; |
||

389 | |||

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

391 | be8ffec9 | Nick Kurshev | |

392 | return 0; |
||

393 | } |
||

394 | |||

395 | 59fcece9 | Mike Melanson | static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf, |

396 | be8ffec9 | Nick Kurshev | ```
uint8_t *current, uint8_t *previous, int pitch,
``` |

397 | svq1_pmv_t *motion,int x, int y) { |
||

398 | uint8_t *src; |
||

399 | uint8_t *dst; |
||

400 | svq1_pmv_t mv; |
||

401 | ```
svq1_pmv_t *pmv[4];
``` |
||

402 | ```
int i, result;
``` |
||

403 | |||

404 | ```
/* predict and decode motion vector (0) */
``` |
||

405 | pmv[0] = &motion[0]; |
||

406 | if (y == 0) { |
||

407 | 82dd7d0d | Nick Kurshev | ```
pmv[1] =
``` |

408 | be8ffec9 | Nick Kurshev | pmv[2] = pmv[0]; |

409 | } |
||

410 | 82dd7d0d | Nick Kurshev | ```
else {
``` |

411 | pmv[1] = &motion[(x / 8) + 2]; |
||

412 | pmv[2] = &motion[(x / 8) + 4]; |
||

413 | } |
||

414 | be8ffec9 | Nick Kurshev | |

415 | 82dd7d0d | Nick Kurshev | result = svq1_decode_motion_vector (bitbuf, &mv, pmv); |

416 | be8ffec9 | Nick Kurshev | |

417 | if (result != 0) |
||

418 | ```
return result;
``` |
||

419 | |||

420 | ```
/* predict and decode motion vector (1) */
``` |
||

421 | ```
pmv[0] = &mv;
``` |
||

422 | if (y == 0) { |
||

423 | 82dd7d0d | Nick Kurshev | ```
pmv[1] =
``` |

424 | be8ffec9 | Nick Kurshev | pmv[2] = pmv[0]; |

425 | } |
||

426 | 82dd7d0d | Nick Kurshev | ```
else {
``` |

427 | pmv[1] = &motion[(x / 8) + 3]; |
||

428 | } |
||

429 | ```
result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
``` |
||

430 | be8ffec9 | Nick Kurshev | |

431 | if (result != 0) |
||

432 | ```
return result;
``` |
||

433 | |||

434 | ```
/* predict and decode motion vector (2) */
``` |
||

435 | pmv[1] = &motion[0]; |
||

436 | pmv[2] = &motion[(x / 8) + 1]; |
||

437 | |||

438 | 82dd7d0d | Nick Kurshev | result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv); |

439 | be8ffec9 | Nick Kurshev | |

440 | if (result != 0) |
||

441 | ```
return result;
``` |
||

442 | |||

443 | ```
/* predict and decode motion vector (3) */
``` |
||

444 | pmv[2] = &motion[(x / 8) + 2]; |
||

445 | pmv[3] = &motion[(x / 8) + 3]; |
||

446 | |||

447 | 82dd7d0d | Nick Kurshev | ```
result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
``` |

448 | be8ffec9 | Nick Kurshev | |

449 | if (result != 0) |
||

450 | ```
return result;
``` |
||

451 | |||

452 | ```
/* form predictions */
``` |
||

453 | for (i=0; i < 4; i++) { |
||

454 | b739d676 | Michael Niedermayer | int mvx= pmv[i]->x + (i&1)*16; |

455 | int mvy= pmv[i]->y + (i>>1)*16; |
||

456 | |||

457 | ```
///XXX /FIXME cliping or padding?
``` |
||

458 | if(y + (mvy >> 1)<0) |
||

459 | ```
mvy= 0;
``` |
||

460 | if(x + (mvx >> 1)<0) |
||

461 | ```
mvx= 0;
``` |
||

462 | |||

463 | ```
#if 0
``` |
||

464 | ```
int w= (s->width+15)&~15;
``` |
||

465 | ```
int h= (s->height+15)&~15;
``` |
||

466 | ```
if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
``` |
||

467 | ```
printf("%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
``` |
||

468 | ```
#endif
``` |
||

469 | src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch]; |
||

470 | be8ffec9 | Nick Kurshev | dst = current; |

471 | b739d676 | Michael Niedermayer | |

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

473 | be8ffec9 | Nick Kurshev | |

474 | ```
/* select next block */
``` |
||

475 | if (i & 1) { |
||

476 | current += 8*(pitch - 1); |
||

477 | ```
} else {
``` |
||

478 | ```
current += 8;
``` |
||

479 | } |
||

480 | } |
||

481 | |||

482 | return 0; |
||

483 | } |
||

484 | |||

485 | 59fcece9 | Mike Melanson | static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf, |

486 | be8ffec9 | Nick Kurshev | ```
uint8_t *current, uint8_t *previous, int pitch,
``` |

487 | svq1_pmv_t *motion, int x, int y) { |
||

488 | uint32_t block_type; |
||

489 | int result = 0; |
||

490 | |||

491 | ```
/* get block type */
``` |
||

492 | 59fcece9 | Mike Melanson | block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2); |

493 | be8ffec9 | Nick Kurshev | |

494 | ```
/* reset motion vectors */
``` |
||

495 | ```
if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
``` |
||

496 | 82dd7d0d | Nick Kurshev | ```
motion[0].x =
``` |

497 | ```
motion[0].y =
``` |
||

498 | motion[(x / 8) + 2].x = |
||

499 | motion[(x / 8) + 2].y = |
||

500 | motion[(x / 8) + 3].x = |
||

501 | be8ffec9 | Nick Kurshev | motion[(x / 8) + 3].y = 0; |

502 | } |
||

503 | |||

504 | ```
switch (block_type) {
``` |
||

505 | ```
case SVQ1_BLOCK_SKIP:
``` |
||

506 | 82dd7d0d | Nick Kurshev | svq1_skip_block (current, previous, pitch, x, y); |

507 | be8ffec9 | Nick Kurshev | ```
break;
``` |

508 | |||

509 | ```
case SVQ1_BLOCK_INTER:
``` |
||

510 | eb4b3dd3 | Zdenek Kabelac | result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y); |

511 | be8ffec9 | Nick Kurshev | |

512 | if (result != 0) |
||

513 | { |
||

514 | ```
#ifdef DEBUG_SVQ1
``` |
||

515 | 82dd7d0d | Nick Kurshev | ```
printf("Error in svq1_motion_inter_block %i\n",result);
``` |

516 | be8ffec9 | Nick Kurshev | ```
#endif
``` |

517 | ```
break;
``` |
||

518 | } |
||

519 | 82dd7d0d | Nick Kurshev | result = svq1_decode_block_non_intra (bitbuf, current, pitch); |

520 | be8ffec9 | Nick Kurshev | ```
break;
``` |

521 | |||

522 | ```
case SVQ1_BLOCK_INTER_4V:
``` |
||

523 | eb4b3dd3 | Zdenek Kabelac | result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y); |

524 | be8ffec9 | Nick Kurshev | |

525 | if (result != 0) |
||

526 | { |
||

527 | ```
#ifdef DEBUG_SVQ1
``` |
||

528 | 82dd7d0d | Nick Kurshev | ```
printf("Error in svq1_motion_inter_4v_block %i\n",result);
``` |

529 | be8ffec9 | Nick Kurshev | ```
#endif
``` |

530 | ```
break;
``` |
||

531 | } |
||

532 | 82dd7d0d | Nick Kurshev | result = svq1_decode_block_non_intra (bitbuf, current, pitch); |

533 | be8ffec9 | Nick Kurshev | ```
break;
``` |

534 | |||

535 | ```
case SVQ1_BLOCK_INTRA:
``` |
||

536 | 82dd7d0d | Nick Kurshev | result = svq1_decode_block_intra (bitbuf, current, pitch); |

537 | be8ffec9 | Nick Kurshev | ```
break;
``` |

538 | } |
||

539 | |||

540 | ```
return result;
``` |
||

541 | } |
||

542 | |||

543 | ```
/* standard video sizes */
``` |
||

544 | 82dd7d0d | Nick Kurshev | static struct { int width; int height; } svq1_frame_size_table[8] = { |

545 | be8ffec9 | Nick Kurshev | { 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 }, |

546 | { 704, 576 }, { 240, 180 }, { 320, 240 }, { -1, -1 } |
||

547 | }; |
||

548 | |||

549 | 59fcece9 | Mike Melanson | static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) { |

550 | ```
int i;
``` |
||

551 | |||

552 | for (i=0; i < length; i++) { |
||

553 | value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8); |
||

554 | } |
||

555 | |||

556 | ```
return value;
``` |
||

557 | } |
||

558 | |||

559 | static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch, |
||

560 | int width, int height, int value) { |
||

561 | ```
int x, y;
``` |
||

562 | |||

563 | for (y=0; y < height; y++) { |
||

564 | for (x=0; x < width; x++) { |
||

565 | value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8); |
||

566 | } |
||

567 | |||

568 | pixels += pitch; |
||

569 | } |
||

570 | |||

571 | ```
return value;
``` |
||

572 | } |
||

573 | |||

574 | static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) { |
||

575 | uint8_t seed; |
||

576 | ```
int i;
``` |
||

577 | |||

578 | out[0] = get_bits (bitbuf, 8); |
||

579 | |||

580 | ```
seed = string_table[out[0]];
``` |
||

581 | |||

582 | for (i=1; i < out[0]; i++) { |
||

583 | ```
out[i] = get_bits (bitbuf, 8) ^ seed;
``` |
||

584 | seed = string_table[out[i] ^ seed]; |
||

585 | } |
||

586 | } |
||

587 | |||

588 | static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) { |
||

589 | be8ffec9 | Nick Kurshev | ```
int frame_size_code;
``` |

590 | 59fcece9 | Mike Melanson | ```
int temporal_reference;
``` |

591 | be8ffec9 | Nick Kurshev | |

592 | 59fcece9 | Mike Melanson | ```
temporal_reference = get_bits (bitbuf, 8);
``` |

593 | be8ffec9 | Nick Kurshev | |

594 | ```
/* frame type */
``` |
||

595 | 760acb18 | Michael Niedermayer | s->pict_type= get_bits (bitbuf, 2)+1; |

596 | if(s->pict_type==4) |
||

597 | return -1; |
||

598 | b739d676 | Michael Niedermayer | |

599 | 760acb18 | Michael Niedermayer | ```
if (s->pict_type == I_TYPE) {
``` |

600 | be8ffec9 | Nick Kurshev | |

601 | ```
/* unknown fields */
``` |
||

602 | if (s->f_code == 0x50 || s->f_code == 0x60) { |
||

603 | 59fcece9 | Mike Melanson | int csum = get_bits (bitbuf, 16); |

604 | |||

605 | ```
csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
``` |
||

606 | |||

607 | ```
// printf ("%s checksum (%02x) for packet data\n",
``` |
||

608 | ```
// (csum == 0) ? "correct" : "incorrect", csum);
``` |
||

609 | be8ffec9 | Nick Kurshev | } |

610 | |||

611 | if ((s->f_code ^ 0x10) >= 0x50) { |
||

612 | 59fcece9 | Mike Melanson | char msg[256]; |

613 | |||

614 | ```
svq1_parse_string (bitbuf, (char *) msg);
``` |
||

615 | |||

616 | printf ("embedded message: \"%s\"\n", (char *) msg); |
||

617 | be8ffec9 | Nick Kurshev | } |

618 | |||

619 | 0c938bd1 | Alex Beregszaszi | ```
skip_bits (bitbuf, 2);
``` |

620 | ```
skip_bits (bitbuf, 2);
``` |
||

621 | skip_bits1 (bitbuf); |
||

622 | be8ffec9 | Nick Kurshev | |

623 | ```
/* load frame size */
``` |
||

624 | ```
frame_size_code = get_bits (bitbuf, 3);
``` |
||

625 | |||

626 | if (frame_size_code == 7) { |
||

627 | ```
/* load width, height (12 bits each) */
``` |
||

628 | ```
s->width = get_bits (bitbuf, 12);
``` |
||

629 | ```
s->height = get_bits (bitbuf, 12);
``` |
||

630 | |||

631 | ```
if (!s->width || !s->height)
``` |
||

632 | return -1; |
||

633 | ```
} else {
``` |
||

634 | ```
/* get width, height from table */
``` |
||

635 | 82dd7d0d | Nick Kurshev | s->width = svq1_frame_size_table[frame_size_code].width; |

636 | s->height = svq1_frame_size_table[frame_size_code].height; |
||

637 | be8ffec9 | Nick Kurshev | } |

638 | } |
||

639 | |||

640 | ```
/* unknown fields */
``` |
||

641 | if (get_bits (bitbuf, 1) == 1) { |
||

642 | 0c938bd1 | Alex Beregszaszi | ```
skip_bits1 (bitbuf); /* use packet checksum if (1) */
``` |

643 | ```
skip_bits1 (bitbuf); /* component checksums after image data if (1) */
``` |
||

644 | be8ffec9 | Nick Kurshev | |

645 | if (get_bits (bitbuf, 2) != 0) |
||

646 | return -1; |
||

647 | } |
||

648 | |||

649 | if (get_bits (bitbuf, 1) == 1) { |
||

650 | 0c938bd1 | Alex Beregszaszi | skip_bits1 (bitbuf); |

651 | ```
skip_bits (bitbuf, 4);
``` |
||

652 | skip_bits1 (bitbuf); |
||

653 | ```
skip_bits (bitbuf, 2);
``` |
||

654 | be8ffec9 | Nick Kurshev | |

655 | while (get_bits (bitbuf, 1) == 1) { |
||

656 | 0c938bd1 | Alex Beregszaszi | ```
skip_bits (bitbuf, 8);
``` |

657 | be8ffec9 | Nick Kurshev | } |

658 | } |
||

659 | |||

660 | return 0; |
||

661 | } |
||

662 | |||

663 | static int svq1_decode_frame(AVCodecContext *avctx, |
||

664 | void *data, int *data_size, |
||

665 | 0c1a9eda | Zdenek Kabelac | ```
uint8_t *buf, int buf_size)
``` |

666 | be8ffec9 | Nick Kurshev | { |

667 | MpegEncContext *s=avctx->priv_data; |
||

668 | uint8_t *current, *previous; |
||

669 | ```
int result, i, x, y, width, height;
``` |
||

670 | 492cd3a9 | Michael Niedermayer | AVFrame *pict = data; |

671 | be8ffec9 | Nick Kurshev | |

672 | ```
/* initialize bit buffer */
``` |
||

673 | 68f593b4 | Michael Niedermayer | ```
init_get_bits(&s->gb,buf,buf_size*8);
``` |

674 | be8ffec9 | Nick Kurshev | |

675 | ```
/* decode frame header */
``` |
||

676 | ```
s->f_code = get_bits (&s->gb, 22);
``` |
||

677 | |||

678 | if ((s->f_code & ~0x70) || !(s->f_code & 0x60)) |
||

679 | return -1; |
||

680 | |||

681 | ```
/* swap some header bytes (why?) */
``` |
||

682 | if (s->f_code != 0x20) { |
||

683 | ```
uint32_t *src = (uint32_t *) (buf + 4);
``` |
||

684 | |||

685 | for (i=0; i < 4; i++) { |
||

686 | src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; |
||

687 | } |
||

688 | } |
||

689 | |||

690 | 82dd7d0d | Nick Kurshev | result = svq1_decode_frame_header (&s->gb, s); |

691 | be8ffec9 | Nick Kurshev | |

692 | if (result != 0) |
||

693 | { |
||

694 | ```
#ifdef DEBUG_SVQ1
``` |
||

695 | 82dd7d0d | Nick Kurshev | ```
printf("Error in svq1_decode_frame_header %i\n",result);
``` |

696 | be8ffec9 | Nick Kurshev | ```
#endif
``` |

697 | ```
return result;
``` |
||

698 | } |
||

699 | bc6d7776 | Michael Niedermayer | |

700 | e5ab4fdd | Michael Niedermayer | ```
//FIXME this avoids some confusion for "B frames" without 2 references
``` |

701 | ```
//this should be removed after libavcodec can handle more flaxible picture types & ordering
``` |
||

702 | b536d0aa | Michael Niedermayer | if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size; |

703 | e5ab4fdd | Michael Niedermayer | |

704 | bc6d7776 | Michael Niedermayer | if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size; |

705 | be8ffec9 | Nick Kurshev | |

706 | 1e491e29 | Michael Niedermayer | if(MPV_frame_start(s, avctx) < 0) |

707 | return -1; |
||

708 | |||

709 | be8ffec9 | Nick Kurshev | ```
/* decode y, u and v components */
``` |

710 | for (i=0; i < 3; i++) { |
||

711 | 760acb18 | Michael Niedermayer | ```
int linesize;
``` |

712 | be8ffec9 | Nick Kurshev | if (i == 0) { |

713 | 82dd7d0d | Nick Kurshev | width = (s->width+15)&~15; |

714 | height = (s->height+15)&~15; |
||

715 | 760acb18 | Michael Niedermayer | linesize= s->linesize; |

716 | be8ffec9 | Nick Kurshev | ```
} else {
``` |

717 | 22b13d5b | Michael Niedermayer | if(s->flags&CODEC_FLAG_GRAY) break; |

718 | 82dd7d0d | Nick Kurshev | width = (s->width/4+15)&~15; |

719 | height = (s->height/4+15)&~15; |
||

720 | 760acb18 | Michael Niedermayer | linesize= s->uvlinesize; |

721 | be8ffec9 | Nick Kurshev | } |

722 | |||

723 | 1e491e29 | Michael Niedermayer | current = s->current_picture.data[i]; |

724 | be8ffec9 | Nick Kurshev | |

725 | 760acb18 | Michael Niedermayer | ```
if(s->pict_type==B_TYPE){
``` |

726 | 1e491e29 | Michael Niedermayer | previous = s->next_picture.data[i]; |

727 | 760acb18 | Michael Niedermayer | ```
}else{
``` |

728 | 1e491e29 | Michael Niedermayer | previous = s->last_picture.data[i]; |

729 | 760acb18 | Michael Niedermayer | } |

730 | |||

731 | ```
if (s->pict_type == I_TYPE) {
``` |
||

732 | be8ffec9 | Nick Kurshev | ```
/* keyframe */
``` |

733 | for (y=0; y < height; y+=16) { |
||

734 | for (x=0; x < width; x+=16) { |
||

735 | 760acb18 | Michael Niedermayer | result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize); |

736 | be8ffec9 | Nick Kurshev | if (result != 0) |

737 | { |
||

738 | ```
#ifdef DEBUG_SVQ1
``` |
||

739 | 82dd7d0d | Nick Kurshev | ```
printf("Error in svq1_decode_block %i (keyframe)\n",result);
``` |

740 | be8ffec9 | Nick Kurshev | ```
#endif
``` |

741 | ```
return result;
``` |
||

742 | } |
||

743 | } |
||

744 | 760acb18 | Michael Niedermayer | ```
current += 16*linesize;
``` |

745 | be8ffec9 | Nick Kurshev | } |

746 | ```
} else {
``` |
||

747 | 760acb18 | Michael Niedermayer | svq1_pmv_t pmv[width/8+3]; |

748 | be8ffec9 | Nick Kurshev | ```
/* delta frame */
``` |

749 | 760acb18 | Michael Niedermayer | memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t)); |

750 | be8ffec9 | Nick Kurshev | |

751 | for (y=0; y < height; y+=16) { |
||

752 | for (x=0; x < width; x+=16) { |
||

753 | eb4b3dd3 | Zdenek Kabelac | result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous, |

754 | linesize, pmv, x, y); |
||

755 | be8ffec9 | Nick Kurshev | if (result != 0) |

756 | { |
||

757 | ```
#ifdef DEBUG_SVQ1
``` |
||

758 | 82dd7d0d | Nick Kurshev | ```
printf("Error in svq1_decode_delta_block %i\n",result);
``` |

759 | be8ffec9 | Nick Kurshev | ```
#endif
``` |

760 | ```
return result;
``` |
||

761 | } |
||

762 | } |
||

763 | |||

764 | 760acb18 | Michael Niedermayer | ```
pmv[0].x =
``` |

765 | pmv[0].y = 0; |
||

766 | be8ffec9 | Nick Kurshev | |

767 | 760acb18 | Michael Niedermayer | ```
current += 16*linesize;
``` |

768 | be8ffec9 | Nick Kurshev | } |

769 | } |
||

770 | } |
||

771 | 1e491e29 | Michael Niedermayer | |

772 | 492cd3a9 | Michael Niedermayer | *pict = *(AVFrame*)&s->current_picture; |

773 | 760acb18 | Michael Niedermayer | |

774 | 1e491e29 | Michael Niedermayer | |

775 | MPV_frame_end(s); |
||

776 | |||

777 | 492cd3a9 | Michael Niedermayer | ```
*data_size=sizeof(AVFrame);
``` |

778 | bc6d7776 | Michael Niedermayer | ```
return buf_size;
``` |

779 | be8ffec9 | Nick Kurshev | } |

780 | |||

781 | static int svq1_decode_init(AVCodecContext *avctx) |
||

782 | { |
||

783 | MpegEncContext *s = avctx->priv_data; |
||

784 | 59fcece9 | Mike Melanson | ```
int i;
``` |

785 | ce23c668 | Alex Beregszaszi | |

786 | be8ffec9 | Nick Kurshev | s->avctx = avctx; |

787 | s->width = (avctx->width+3)&~3; |
||

788 | s->height = (avctx->height+3)&~3; |
||

789 | s->codec_id= avctx->codec->id; |
||

790 | avctx->pix_fmt = PIX_FMT_YUV410P; |
||

791 | 4e00e76b | Michael Niedermayer | avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames |

792 | 22b13d5b | Michael Niedermayer | s->flags= avctx->flags; |

793 | 760acb18 | Michael Niedermayer | if (MPV_common_init(s) < 0) return -1; |

794 | 59fcece9 | Mike Melanson | |

795 | init_vlc(&svq1_block_type, 2, 4, |
||

796 | &svq1_block_type_vlc[0][1], 2, 1, |
||

797 | &svq1_block_type_vlc[0][0], 2, 1); |
||

798 | |||

799 | init_vlc(&svq1_motion_component, 7, 65, |
||

800 | &svq1_motion_component_vlc[0][1], 4, 2, |
||

801 | &svq1_motion_component_vlc[0][0], 4, 2); |
||

802 | |||

803 | for (i = 0; i < 6; i++) { |
||

804 | init_vlc(&svq1_intra_multistage[i], 3, 8, |
||

805 | &svq1_intra_multistage_vlc[i][0][1], 2, 1, |
||

806 | &svq1_intra_multistage_vlc[i][0][0], 2, 1); |
||

807 | init_vlc(&svq1_inter_multistage[i], 3, 8, |
||

808 | &svq1_inter_multistage_vlc[i][0][1], 2, 1, |
||

809 | &svq1_inter_multistage_vlc[i][0][0], 2, 1); |
||

810 | } |
||

811 | |||

812 | init_vlc(&svq1_intra_mean, 8, 256, |
||

813 | &svq1_intra_mean_vlc[0][1], 4, 2, |
||

814 | &svq1_intra_mean_vlc[0][0], 4, 2); |
||

815 | |||

816 | init_vlc(&svq1_inter_mean, 9, 512, |
||

817 | &svq1_inter_mean_vlc[0][1], 4, 2, |
||

818 | &svq1_inter_mean_vlc[0][0], 4, 2); |
||

819 | |||

820 | be8ffec9 | Nick Kurshev | return 0; |

821 | } |
||

822 | |||

823 | static int svq1_decode_end(AVCodecContext *avctx) |
||

824 | { |
||

825 | MpegEncContext *s = avctx->priv_data; |
||

826 | |||

827 | MPV_common_end(s); |
||

828 | return 0; |
||

829 | } |
||

830 | |||

831 | AVCodec svq1_decoder = { |
||

832 | ```
"svq1",
``` |
||

833 | CODEC_TYPE_VIDEO, |
||

834 | CODEC_ID_SVQ1, |
||

835 | ```
sizeof(MpegEncContext),
``` |
||

836 | svq1_decode_init, |
||

837 | ```
NULL,
``` |
||

838 | svq1_decode_end, |
||

839 | 760acb18 | Michael Niedermayer | svq1_decode_frame, |

840 | CODEC_CAP_DR1, |
||

841 | 7a06ff14 | Michael Niedermayer | .flush= ff_mpeg_flush, |

842 | be8ffec9 | Nick Kurshev | }; |