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 if ((ret = av_image_check_size(avctx->coded_width,

453 avctx->coded_height, 0, avctx)) < 0)

454 return ret;

455

456 ff_MPV_decode_defaults(s);

457

458 s->avctx = avctx;

459 s->out_format = FMT_H263;

460 s->codec_id = avctx->codec_id;

461

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

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

464

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

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

467

468 major_ver = RV_GET_MAJOR_VER(rv->sub_id);

469 minor_ver = RV_GET_MINOR_VER(rv->sub_id);

470 micro_ver = RV_GET_MICRO_VER(rv->sub_id);

471

472 s->low_delay = 1;

473 switch (major_ver) {

474 case 1:

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

476 s->obmc = micro_ver == 2;

477 break;

478 case 2:

479 if (minor_ver >= 2) {

480 s->low_delay = 0;

481 s->avctx->has_b_frames = 1;

482 }

483 break;

484 default:

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

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

487 return AVERROR_PATCHWELCOME;

488 }

489

490 if (avctx->debug & FF_DEBUG_PICT_INFO) {

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

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

493 }

494

495 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

496

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

498 return ret;

499

500 ff_h263_decode_init_vlc();

501

502 /* init rv vlc */

503 if (!done) {

504 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,

505 rv_lum_bits, 1, 1,

506 rv_lum_code, 2, 2, 16384);

507 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,

508 rv_chrom_bits, 1, 1,

509 rv_chrom_code, 2, 2, 16388);

510 done = 1;

511 }

512

513 return 0;

514 }

515

516 static av_cold int rv10_decode_end(AVCodecContext *avctx)

517 {

518 MpegEncContext *s = avctx->priv_data;

519

520 ff_MPV_common_end(s);

521 return 0;

522 }

523

524 static int rv10_decode_packet(AVCodecContext *avctx,

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

526 {

527 RVDecContext *rv = avctx->priv_data;

528 MpegEncContext *s = &rv->m;

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

530

531 active_bits_size = buf_size * 8;

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

533 if (s->codec_id == AV_CODEC_ID_RV10)

534 mb_count = rv10_decode_picture_header(s);

535 else

536 mb_count = rv20_decode_picture_header(rv);

537 if (mb_count < 0) {

538 if (mb_count != ERROR_SKIP_FRAME)

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

540 return AVERROR_INVALIDDATA;

541 }

542

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

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

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

546 return AVERROR_INVALIDDATA;

547 }

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

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

550 if (mb_count > left) {

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

552 return AVERROR_INVALIDDATA;

553 }

554

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

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

557 ff_er_frame_end(&s->er);

558 ff_MPV_frame_end(s);

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

560 }

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

562 return ret;

563 ff_mpeg_er_frame_start(s);

564 } else {

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

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

567 return AVERROR_INVALIDDATA;

568 }

569 }

570

571

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

573

574 /* default quantization values */

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

576 if (s->mb_y == 0)

577 s->first_slice_line = 1;

578 } else {

579 s->first_slice_line = 1;

580 s->resync_mb_x = s->mb_x;

581 }

582 start_mb_x = s->mb_x;

583 s->resync_mb_y = s->mb_y;

584 if (s->h263_aic) {

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

586 } else {

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

588 }

589

590 if (s->modified_quant)

591 s->chroma_qscale_table = ff_h263_chroma_qscale_table;

592

593 ff_set_qscale(s, s->qscale);

594

595 s->rv10_first_dc_coded[0] = 0;

596 s->rv10_first_dc_coded[1] = 0;

597 s->rv10_first_dc_coded[2] = 0;

598 s->block_wrap[0] =

599 s->block_wrap[1] =

600 s->block_wrap[2] =

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

602 s->block_wrap[4] =

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

604 ff_init_block_index(s);

605

606 /* decode each macroblock */

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

608 int ret;

609 ff_update_block_index(s);

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

611

612 s->mv_dir = MV_DIR_FORWARD;

613 s->mv_type = MV_TYPE_16X16;

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

615

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

617 // bitstream size

618 if (ret != SLICE_ERROR) {

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

620

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

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

623

624 if (!v)

625 ret = SLICE_END;

626 }

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

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

629 active_bits_size = buf_size2 * 8;

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

631 8 * buf_size, active_bits_size);

632 ret = SLICE_OK;

633 }

634

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

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

637 return AVERROR_INVALIDDATA;

638 }

639 if (s->pict_type != AV_PICTURE_TYPE_B)

640 ff_h263_update_motion_val(s);

641 ff_MPV_decode_mb(s, s->block);

642 if (s->loop_filter)

643 ff_h263_loop_filter(s);

644

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

646 s->mb_x = 0;

647 s->mb_y++;

648 ff_init_block_index(s);

649 }

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

651 s->first_slice_line = 0;

652 if (ret == SLICE_END)

653 break;

654 }

655

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

657 ER_MB_END);

658

659 return active_bits_size;

660 }

661

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

663 {

664 if (avctx->slice_count)

665 return avctx->slice_offset[n];

666 else

667 return AV_RL32(buf + n * 8);

668 }

669

670 static int rv10_decode_frame(AVCodecContext *avctx,

671 void *data, int *got_frame,

672 AVPacket *avpkt)

673 {

674 const uint8_t *buf = avpkt->data;

675 int buf_size = avpkt->size;

676 MpegEncContext *s = avctx->priv_data;

677 AVFrame *pict = data;

678 int i, ret;

679 int slice_count;

680 const uint8_t *slices_hdr = NULL;

681

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

683 s->flags = avctx->flags;

684 s->flags2 = avctx->flags2;

685

686 /* no supplementary picture */

687 if (buf_size == 0) {

688 return 0;

689 }

690

691 if (!avctx->slice_count) {

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

693 buf_size--;

694

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

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

697 return AVERROR_INVALIDDATA;

698 }

699

700 slices_hdr = buf + 4;

701 buf += 8 * slice_count;

702 buf_size -= 8 * slice_count;

703 } else

704 slice_count = avctx->slice_count;

705

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

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

708 int size, size2;

709

710 if (offset >= buf_size)

711 return AVERROR_INVALIDDATA;

712

713 if (i + 1 == slice_count)

714 size = buf_size - offset;

715 else

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

717

718 if (i + 2 >= slice_count)

719 size2 = buf_size - offset;

720 else

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

722

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

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

725 return AVERROR_INVALIDDATA;

726

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

728 i++;

729 }

730

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

732 ff_er_frame_end(&s->er);

733 ff_MPV_frame_end(s);

734

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

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

737 return ret;

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

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

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

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

742 return ret;

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

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

745 }

746

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

748 *got_frame = 1;

749 }

750

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

752 s->current_picture_ptr = NULL;

753 }

754

755 return avpkt->size;

756 }

757

758 AVCodec ff_rv10_decoder = {

759 .name = "rv10",

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

761 .type = AVMEDIA_TYPE_VIDEO,

762 .id = AV_CODEC_ID_RV10,

763 .priv_data_size = sizeof(RVDecContext),

764 .init = rv10_decode_init,

765 .close = rv10_decode_end,

766 .decode = rv10_decode_frame,

767 .capabilities = CODEC_CAP_DR1,

768 .max_lowres = 3,

769 .pix_fmts = ff_pixfmt_list_420,

770 };

771

772 AVCodec ff_rv20_decoder = {

773 .name = "rv20",

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

775 .type = AVMEDIA_TYPE_VIDEO,

776 .id = AV_CODEC_ID_RV20,

777 .priv_data_size = sizeof(RVDecContext),

778 .init = rv10_decode_init,

779 .close = rv10_decode_end,

780 .decode = rv10_decode_frame,

781 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,

782 .flush = ff_mpeg_flush,

783 .max_lowres = 3,

784 .pix_fmts = ff_pixfmt_list_420,

785 };

Generated on Sat Jan 25 2014 19:51:54 for FFmpeg by doxygen 1.8.2