FFmpeg: libavcodec/rv10.c Source File

FFmpeg

[フレーム]

libavcodec

rv10.c

Go to the documentation of this file.

1 /*

2 * RV10/RV20 decoder

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 /**

24 * @file

25 * RV10/RV20 decoder

26 */

28 #include "libavutil/imgutils.h"

29 #include "avcodec.h"

30 #include "error_resilience.h"

31 #include "mpegvideo.h"

32 #include "mpeg4video.h"

33 #include "h263.h"

35 #define RV_GET_MAJOR_VER(x) ((x) >> 28)

36 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)

37 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)

39 #define DC_VLC_BITS 14 //FIXME find a better solution

41 typedef struct RVDecContext {

42 MpegEncContext m;

43 int sub_id;

44 } RVDecContext;

46 static const uint16_t rv_lum_code[256] = {

47 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,

48 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,

49 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,

50 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,

51 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,

52 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,

53 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,

54 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,

55 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,

56 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,

57 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,

58 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,

59 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,

60 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,

61 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,

62 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,

63 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,

64 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,

65 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,

66 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,

67 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,

68 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,

69 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,

70 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,

71 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,

72 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,

73 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,

74 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,

75 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,

76 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,

77 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,

78 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,

79 };

81 static const uint8_t rv_lum_bits[256] = {

82 14, 12, 12, 12, 12, 12, 12, 12,

83 12, 12, 12, 12, 12, 12, 12, 12,

84 12, 12, 12, 12, 12, 12, 12, 12,

85 12, 12, 12, 12, 12, 12, 12, 12,

86 12, 12, 12, 12, 12, 12, 12, 12,

87 12, 12, 12, 12, 12, 12, 12, 12,

88 12, 12, 12, 12, 12, 12, 12, 12,

89 12, 12, 12, 12, 12, 12, 12, 12,

90 12, 10, 10, 10, 10, 10, 10, 10,

91 10, 10, 10, 10, 10, 10, 10, 10,

92 10, 10, 10, 10, 10, 10, 10, 10,

93 10, 10, 10, 10, 10, 10, 10, 10,

94 10, 8, 8, 8, 8, 8, 8, 8,

95 8, 8, 8, 8, 8, 8, 8, 8,

96 8, 7, 7, 7, 7, 7, 7, 7,

97 7, 6, 6, 6, 6, 5, 5, 4,

98 2, 4, 5, 5, 6, 6, 6, 6,

99 7, 7, 7, 7, 7, 7, 7, 7,

100 8, 8, 8, 8, 8, 8, 8, 8,

101 8, 8, 8, 8, 8, 8, 8, 8,

102 10, 10, 10, 10, 10, 10, 10, 10,

103 10, 10, 10, 10, 10, 10, 10, 10,

104 10, 10, 10, 10, 10, 10, 10, 10,

105 10, 10, 10, 10, 10, 10, 10, 10,

106 12, 12, 12, 12, 12, 12, 12, 12,

107 12, 12, 12, 12, 12, 12, 12, 12,

108 12, 12, 12, 12, 12, 12, 12, 12,

109 12, 12, 12, 12, 12, 12, 12, 12,

110 12, 12, 12, 12, 12, 12, 12, 12,

111 12, 12, 12, 12, 12, 12, 12, 12,

112 12, 12, 12, 12, 12, 12, 12, 12,

113 12, 12, 12, 12, 12, 12, 12, 12,

114 };

115

116 static const uint16_t rv_chrom_code[256] = {

117 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,

118 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,

119 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,

120 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,

121 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,

122 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,

123 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,

124 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,

125 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,

126 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,

127 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,

128 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,

129 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,

130 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,

131 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,

132 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,

133 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,

134 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,

135 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,

136 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,

137 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,

138 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,

139 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,

140 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,

141 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,

142 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,

143 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,

144 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,

145 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,

146 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,

147 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,

148 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,

149 };

150

151 static const uint8_t rv_chrom_bits[256] = {

152 16, 14, 14, 14, 14, 14, 14, 14,

153 14, 14, 14, 14, 14, 14, 14, 14,

154 14, 14, 14, 14, 14, 14, 14, 14,

155 14, 14, 14, 14, 14, 14, 14, 14,

156 14, 14, 14, 14, 14, 14, 14, 14,

157 14, 14, 14, 14, 14, 14, 14, 14,

158 14, 14, 14, 14, 14, 14, 14, 14,

159 14, 14, 14, 14, 14, 14, 14, 14,

160 14, 12, 12, 12, 12, 12, 12, 12,

161 12, 12, 12, 12, 12, 12, 12, 12,

162 12, 12, 12, 12, 12, 12, 12, 12,

163 12, 12, 12, 12, 12, 12, 12, 12,

164 12, 10, 10, 10, 10, 10, 10, 10,

165 10, 10, 10, 10, 10, 10, 10, 10,

166 10, 8, 8, 8, 8, 8, 8, 8,

167 8, 6, 6, 6, 6, 4, 4, 3,

168 2, 3, 4, 4, 6, 6, 6, 6,

169 8, 8, 8, 8, 8, 8, 8, 8,

170 10, 10, 10, 10, 10, 10, 10, 10,

171 10, 10, 10, 10, 10, 10, 10, 10,

172 12, 12, 12, 12, 12, 12, 12, 12,

173 12, 12, 12, 12, 12, 12, 12, 12,

174 12, 12, 12, 12, 12, 12, 12, 12,

175 12, 12, 12, 12, 12, 12, 12, 12,

176 14, 14, 14, 14, 14, 14, 14, 14,

177 14, 14, 14, 14, 14, 14, 14, 14,

178 14, 14, 14, 14, 14, 14, 14, 14,

179 14, 14, 14, 14, 14, 14, 14, 14,

180 14, 14, 14, 14, 14, 14, 14, 14,

181 14, 14, 14, 14, 14, 14, 14, 14,

182 14, 14, 14, 14, 14, 14, 14, 14,

183 14, 14, 14, 14, 14, 14, 14, 14,

184 };

185

186 static VLC rv_dc_lum, rv_dc_chrom;

187

188 int ff_rv_decode_dc(MpegEncContext *s, int n)

189 {

190 int code;

191

192 if (n < 4) {

193 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);

194 if (code < 0) {

195 /* XXX: I don't understand why they use LONGER codes than

196 necessary. The following code would be completely useless

197 if they had thought about it !!! */

198 code = get_bits(&s->gb, 7);

199 if (code == 0x7c) {

200 code = (int8_t)(get_bits(&s->gb, 7) + 1);

201 } else if (code == 0x7d) {

202 code = -128 + get_bits(&s->gb, 7);

203 } else if (code == 0x7e) {

204 if (get_bits1(&s->gb) == 0)

205 code = (int8_t)(get_bits(&s->gb, 8) + 1);

206 else

207 code = (int8_t)(get_bits(&s->gb, 8));

208 } else if (code == 0x7f) {

209 skip_bits(&s->gb, 11);

210 code = 1;

211 }

212 } else {

213 code -= 128;

214 }

215 } else {

216 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);

217 /* same remark */

218 if (code < 0) {

219 code = get_bits(&s->gb, 9);

220 if (code == 0x1fc) {

221 code = (int8_t)(get_bits(&s->gb, 7) + 1);

222 } else if (code == 0x1fd) {

223 code = -128 + get_bits(&s->gb, 7);

224 } else if (code == 0x1fe) {

225 skip_bits(&s->gb, 9);

226 code = 1;

227 } else {

228 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");

229 return 0xffff;

230 }

231 } else {

232 code -= 128;

233 }

234 }

235 return -code;

236 }

237

238 /* read RV 1.0 compatible frame header */

239 static int rv10_decode_picture_header(MpegEncContext *s)

240 {

241 int mb_count, pb_frame, marker, mb_xy;

242

243 marker = get_bits1(&s->gb);

244

245 if (get_bits1(&s->gb))

246 s->pict_type = AV_PICTURE_TYPE_P;

247 else

248 s->pict_type = AV_PICTURE_TYPE_I;

249

250 if (!marker)

251 av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");

252

253 pb_frame = get_bits1(&s->gb);

254

255 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);

256

257 if (pb_frame) {

258 avpriv_request_sample(s->avctx, "pb frame");

259 return AVERROR_PATCHWELCOME;

260 }

261

262 s->qscale = get_bits(&s->gb, 5);

263 if (s->qscale == 0) {

264 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");

265 return AVERROR_INVALIDDATA;

266 }

267

268 if (s->pict_type == AV_PICTURE_TYPE_I) {

269 if (s->rv10_version == 3) {

270 /* specific MPEG like DC coding not used */

271 s->last_dc[0] = get_bits(&s->gb, 8);

272 s->last_dc[1] = get_bits(&s->gb, 8);

273 s->last_dc[2] = get_bits(&s->gb, 8);

274 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],

275 s->last_dc[1], s->last_dc[2]);

276 }

277 }

278 /* if multiple packets per frame are sent, the position at which

279 to display the macroblocks is coded here */

280

281 mb_xy = s->mb_x + s->mb_y * s->mb_width;

282 if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {

283 s->mb_x = get_bits(&s->gb, 6); /* mb_x */

284 s->mb_y = get_bits(&s->gb, 6); /* mb_y */

285 mb_count = get_bits(&s->gb, 12);

286 } else {

287 s->mb_x = 0;

288 s->mb_y = 0;

289 mb_count = s->mb_width * s->mb_height;

290 }

291 skip_bits(&s->gb, 3); /* ignored */

292 s->f_code = 1;

293 s->unrestricted_mv = 1;

294

295 return mb_count;

296 }

297

298 static int rv20_decode_picture_header(RVDecContext *rv)

299 {

300 MpegEncContext *s = &rv->m;

301 int seq, mb_pos, i, ret;

302 int rpr_bits;

303

304 i = get_bits(&s->gb, 2);

305 switch(i) {

306 case 0: s->pict_type = AV_PICTURE_TYPE_I; break;

307 case 1: s->pict_type = AV_PICTURE_TYPE_I; break; //hmm ...

308 case 2: s->pict_type = AV_PICTURE_TYPE_P; break;

309 case 3: s->pict_type = AV_PICTURE_TYPE_B; break;

310 default:

311 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");

312 return AVERROR_INVALIDDATA;

313 }

314

315 if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {

316 av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");

317 return -1;

318 }

319 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {

320 av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");

321 return AVERROR_INVALIDDATA;

322 }

323

324 if (get_bits1(&s->gb)) {

325 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");

326 return AVERROR_INVALIDDATA;

327 }

328

329 s->qscale = get_bits(&s->gb, 5);

330 if (s->qscale == 0) {

331 av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");

332 return AVERROR_INVALIDDATA;

333 }

334

335 if (RV_GET_MINOR_VER(rv->sub_id) >= 2)

336 s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;

337

338 if (RV_GET_MINOR_VER(rv->sub_id) <= 1)

339 seq = get_bits(&s->gb, 8) << 7;

340 else

341 seq = get_bits(&s->gb, 13) << 2;

342

343 rpr_bits = s->avctx->extradata[1] & 7;

344 if (rpr_bits) {

345 int f, new_w, new_h;

346 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);

347

348 f = get_bits(&s->gb, rpr_bits);

349

350 if (f) {

351 if (s->avctx->extradata_size < 8 + 2 * f) {

352 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");

353 return AVERROR_INVALIDDATA;

354 }

355

356 new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];

357 new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];

358 } else {

359 new_w = s->orig_width ;

360 new_h = s->orig_height;

361 }

362 if (new_w != s->width || new_h != s->height) {

363 AVRational old_aspect = s->avctx->sample_aspect_ratio;

364 av_log(s->avctx, AV_LOG_DEBUG,

365 "attempting to change resolution to %dx%d\n", new_w, new_h);

366 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)

367 return AVERROR_INVALIDDATA;

368 ff_MPV_common_end(s);

369

370 // attempt to keep aspect during typical resolution switches

371 if (!old_aspect.num)

372 old_aspect = (AVRational){1, 1};

373 if (2 * new_w * s->height == new_h * s->width)

374 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});

375 if (new_w * s->height == 2 * new_h * s->width)

376 s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});

377 avcodec_set_dimensions(s->avctx, new_w, new_h);

378 s->width = new_w;

379 s->height = new_h;

380 if ((ret = ff_MPV_common_init(s)) < 0)

381 return ret;

382 }

383

384 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {

385 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);

386 }

387 }

388 if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)

389 return AVERROR_INVALIDDATA;

390

391 mb_pos = ff_h263_decode_mba(s);

392

393 seq |= s->time & ~0x7FFF;

394 if (seq - s->time > 0x4000)

395 seq -= 0x8000;

396 if (seq - s->time < -0x4000)

397 seq += 0x8000;

398

399 if (seq != s->time) {

400 if (s->pict_type != AV_PICTURE_TYPE_B) {

401 s->time = seq;

402 s->pp_time = s->time - s->last_non_b_time;

403 s->last_non_b_time = s->time;

404 } else {

405 s->time = seq;

406 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);

407 }

408 }

409 if (s->pict_type == AV_PICTURE_TYPE_B) {

410 if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {

411 av_log(s->avctx, AV_LOG_DEBUG,

412 "messed up order, possible from seeking? skipping current b frame\n");

413 #define ERROR_SKIP_FRAME -123

414 return ERROR_SKIP_FRAME;

415 }

416 ff_mpeg4_init_direct_mv(s);

417 }

418

419 s->no_rounding = get_bits1(&s->gb);

420

421 if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)

422 skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used

423

424 s->f_code = 1;

425 s->unrestricted_mv = 1;

426 s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;

427 s->modified_quant = 1;

428 if (!s->avctx->lowres)

429 s->loop_filter = 1;

430

431 if (s->avctx->debug & FF_DEBUG_PICT_INFO) {

432 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",

433 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);

434 }

435

436 av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);

437

438 return s->mb_width*s->mb_height - mb_pos;

439 }

440

441 static av_cold int rv10_decode_init(AVCodecContext *avctx)

442 {

443 RVDecContext *rv = avctx->priv_data;

444 MpegEncContext *s = &rv->m;

445 static int done = 0;

446 int major_ver, minor_ver, micro_ver, ret;

447

448 if (avctx->extradata_size < 8) {

449 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");

450 return AVERROR_INVALIDDATA;

451 }

452

453 ff_MPV_decode_defaults(s);

454

455 s->avctx = avctx;

456 s->out_format = FMT_H263;

457 s->codec_id = avctx->codec_id;

458

459 s->orig_width = s->width = avctx->coded_width;

460 s->orig_height = s->height = avctx->coded_height;

461

462 s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;

463 rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);

464

465 major_ver = RV_GET_MAJOR_VER(rv->sub_id);

466 minor_ver = RV_GET_MINOR_VER(rv->sub_id);

467 micro_ver = RV_GET_MICRO_VER(rv->sub_id);

468

469 s->low_delay = 1;

470 switch (major_ver) {

471 case 1:

472 s->rv10_version = micro_ver ? 3 : 1;

473 s->obmc = micro_ver == 2;

474 break;

475 case 2:

476 if (minor_ver >= 2) {

477 s->low_delay = 0;

478 s->avctx->has_b_frames = 1;

479 }

480 break;

481 default:

482 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);

483 avpriv_request_sample(avctx, "RV1/2 version");

484 return AVERROR_PATCHWELCOME;

485 }

486

487 if (avctx->debug & FF_DEBUG_PICT_INFO) {

488 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,

489 ((uint32_t*)avctx->extradata)[0]);

490 }

491

492 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

493

494 if ((ret = ff_MPV_common_init(s)) < 0)

495 return ret;

496

497 ff_h263_decode_init_vlc();

498

499 /* init rv vlc */

500 if (!done) {

501 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,

502 rv_lum_bits, 1, 1,

503 rv_lum_code, 2, 2, 16384);

504 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,

505 rv_chrom_bits, 1, 1,

506 rv_chrom_code, 2, 2, 16388);

507 done = 1;

508 }

509

510 return 0;

511 }

512

513 static av_cold int rv10_decode_end(AVCodecContext *avctx)

514 {

515 MpegEncContext *s = avctx->priv_data;

516

517 ff_MPV_common_end(s);

518 return 0;

519 }

520

521 static int rv10_decode_packet(AVCodecContext *avctx,

522 const uint8_t *buf, int buf_size, int buf_size2)

523 {

524 RVDecContext *rv = avctx->priv_data;

525 MpegEncContext *s = &rv->m;

526 int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;

527

528 active_bits_size = buf_size * 8;

529 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);

530 if (s->codec_id == AV_CODEC_ID_RV10)

531 mb_count = rv10_decode_picture_header(s);

532 else

533 mb_count = rv20_decode_picture_header(rv);

534 if (mb_count < 0) {

535 if (mb_count != ERROR_SKIP_FRAME)

536 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");

537 return AVERROR_INVALIDDATA;

538 }

539

540 if (s->mb_x >= s->mb_width ||

541 s->mb_y >= s->mb_height) {

542 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);

543 return AVERROR_INVALIDDATA;

544 }

545 mb_pos = s->mb_y * s->mb_width + s->mb_x;

546 left = s->mb_width * s->mb_height - mb_pos;

547 if (mb_count > left) {

548 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");

549 return AVERROR_INVALIDDATA;

550 }

551

552 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {

553 if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?

554 ff_er_frame_end(&s->er);

555 ff_MPV_frame_end(s);

556 s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;

557 }

558 if ((ret = ff_MPV_frame_start(s, avctx)) < 0)

559 return ret;

560 ff_mpeg_er_frame_start(s);

561 } else {

562 if (s->current_picture_ptr->f.pict_type != s->pict_type) {

563 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");

564 return AVERROR_INVALIDDATA;

565 }

566 }

567

568

569 av_dlog(avctx, "qscale=%d\n", s->qscale);

570

571 /* default quantization values */

572 if (s->codec_id == AV_CODEC_ID_RV10) {

573 if (s->mb_y == 0)

574 s->first_slice_line = 1;

575 } else {

576 s->first_slice_line = 1;

577 s->resync_mb_x = s->mb_x;

578 }

579 start_mb_x = s->mb_x;

580 s->resync_mb_y = s->mb_y;

581 if (s->h263_aic) {

582 s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;

583 } else {

584 s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;

585 }

586

587 if (s->modified_quant)

588 s->chroma_qscale_table = ff_h263_chroma_qscale_table;

589

590 ff_set_qscale(s, s->qscale);

591

592 s->rv10_first_dc_coded[0] = 0;

593 s->rv10_first_dc_coded[1] = 0;

594 s->rv10_first_dc_coded[2] = 0;

595 s->block_wrap[0] =

596 s->block_wrap[1] =

597 s->block_wrap[2] =

598 s->block_wrap[3] = s->b8_stride;

599 s->block_wrap[4] =

600 s->block_wrap[5] = s->mb_stride;

601 ff_init_block_index(s);

602

603 /* decode each macroblock */

604 for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {

605 int ret;

606 ff_update_block_index(s);

607 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);

608

609 s->mv_dir = MV_DIR_FORWARD;

610 s->mv_type = MV_TYPE_16X16;

611 ret = ff_h263_decode_mb(s, s->block);

612

613 // Repeat the slice end check from ff_h263_decode_mb with our active

614 // bitstream size

615 if (ret != SLICE_ERROR) {

616 int v = show_bits(&s->gb, 16);

617

618 if (get_bits_count(&s->gb) + 16 > active_bits_size)

619 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;

620

621 if (!v)

622 ret = SLICE_END;

623 }

624 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&

625 8 * buf_size2 >= get_bits_count(&s->gb)) {

626 active_bits_size = buf_size2 * 8;

627 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",

628 8 * buf_size, active_bits_size);

629 ret = SLICE_OK;

630 }

631

632 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {

633 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);

634 return AVERROR_INVALIDDATA;

635 }

636 if (s->pict_type != AV_PICTURE_TYPE_B)

637 ff_h263_update_motion_val(s);

638 ff_MPV_decode_mb(s, s->block);

639 if (s->loop_filter)

640 ff_h263_loop_filter(s);

641

642 if (++s->mb_x == s->mb_width) {

643 s->mb_x = 0;

644 s->mb_y++;

645 ff_init_block_index(s);

646 }

647 if (s->mb_x == s->resync_mb_x)

648 s->first_slice_line = 0;

649 if (ret == SLICE_END)

650 break;

651 }

652

653 ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,

654 ER_MB_END);

655

656 return active_bits_size;

657 }

658

659 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)

660 {

661 if (avctx->slice_count)

662 return avctx->slice_offset[n];

663 else

664 return AV_RL32(buf + n * 8);

665 }

666

667 static int rv10_decode_frame(AVCodecContext *avctx,

668 void *data, int *got_frame,

669 AVPacket *avpkt)

670 {

671 const uint8_t *buf = avpkt->data;

672 int buf_size = avpkt->size;

673 MpegEncContext *s = avctx->priv_data;

674 AVFrame *pict = data;

675 int i, ret;

676 int slice_count;

677 const uint8_t *slices_hdr = NULL;

678

679 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);

680 s->flags = avctx->flags;

681 s->flags2 = avctx->flags2;

682

683 /* no supplementary picture */

684 if (buf_size == 0) {

685 return 0;

686 }

687

688 if (!avctx->slice_count) {

689 slice_count = (*buf++) + 1;

690 buf_size--;

691

692 if (!slice_count || buf_size <= 8 * slice_count) {

693 av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);

694 return AVERROR_INVALIDDATA;

695 }

696

697 slices_hdr = buf + 4;

698 buf += 8 * slice_count;

699 buf_size -= 8 * slice_count;

700 } else

701 slice_count = avctx->slice_count;

702

703 for (i = 0; i < slice_count; i++) {

704 unsigned offset = get_slice_offset(avctx, slices_hdr, i);

705 int size, size2;

706

707 if (offset >= buf_size)

708 return AVERROR_INVALIDDATA;

709

710 if (i + 1 == slice_count)

711 size = buf_size - offset;

712 else

713 size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;

714

715 if (i + 2 >= slice_count)

716 size2 = buf_size - offset;

717 else

718 size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;

719

720 if (size <= 0 || size2 <= 0 ||

721 offset + FFMAX(size, size2) > buf_size)

722 return AVERROR_INVALIDDATA;

723

724 if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)

725 i++;

726 }

727

728 if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {

729 ff_er_frame_end(&s->er);

730 ff_MPV_frame_end(s);

731

732 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

733 if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)

734 return ret;

735 ff_print_debug_info(s, s->current_picture_ptr, pict);

736 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);

737 } else if (s->last_picture_ptr != NULL) {

738 if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)

739 return ret;

740 ff_print_debug_info(s, s->last_picture_ptr, pict);

741 ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);

742 }

743

744 if (s->last_picture_ptr || s->low_delay) {

745 *got_frame = 1;

746 }

747

748 // so we can detect if frame_end was not called (find some nicer solution...)

749 s->current_picture_ptr = NULL;

750 }

751

752 return avpkt->size;

753 }

754

755 AVCodec ff_rv10_decoder = {

756 .name = "rv10",

757 .type = AVMEDIA_TYPE_VIDEO,

758 .id = AV_CODEC_ID_RV10,

759 .priv_data_size = sizeof(RVDecContext),

760 .init = rv10_decode_init,

761 .close = rv10_decode_end,

762 .decode = rv10_decode_frame,

763 .capabilities = CODEC_CAP_DR1,

764 .max_lowres = 3,

765 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),

766 .pix_fmts = ff_pixfmt_list_420,

767 };

768

769 AVCodec ff_rv20_decoder = {

770 .name = "rv20",

771 .type = AVMEDIA_TYPE_VIDEO,

772 .id = AV_CODEC_ID_RV20,

773 .priv_data_size = sizeof(RVDecContext),

774 .init = rv10_decode_init,

775 .close = rv10_decode_end,

776 .decode = rv10_decode_frame,

777 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,

778 .flush = ff_mpeg_flush,

779 .max_lowres = 3,

780 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),

781 .pix_fmts = ff_pixfmt_list_420,

782 };

Generated on Wed Jul 10 2013 23:48:04 for FFmpeg by doxygen 1.8.2