FFmpeg: libavcodec/4xm.c Source File

FFmpeg

[フレーム]

libavcodec

4xm.c

Go to the documentation of this file.

1 /*

2 * 4XM codec

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * 4XM codec.

25 */

27 #include <inttypes.h>

29 #include "libavutil/avassert.h"

30 #include "libavutil/frame.h"

31 #include "libavutil/imgutils.h"

32 #include "libavutil/intreadwrite.h"

33 #include "avcodec.h"

34 #include "blockdsp.h"

35 #include "bswapdsp.h"

36 #include "bytestream.h"

37 #include "get_bits.h"

38 #include "internal.h"

41 #define BLOCK_TYPE_VLC_BITS 5

42 #define ACDC_VLC_BITS 9

44 #define CFRAME_BUFFER_COUNT 100

46 static const uint8_t block_type_tab[2][4][8][2] = {

47 {

48 { // { 8, 4, 2 } x { 8, 4, 2}

49 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }

50 }, { // { 8, 4 } x 1

51 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }

52 }, { // 1 x { 8, 4 }

53 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }

54 }, { // 1 x 2, 2 x 1

55 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }

56 }

57 }, {

58 { // { 8, 4, 2 } x { 8, 4, 2}

59 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }

60 }, {// { 8, 4 } x 1

61 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }

62 }, {// 1 x { 8, 4 }

63 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }

64 }, {// 1 x 2, 2 x 1

65 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }

66 }

67 }

68 };

70 static const uint8_t size2index[4][4] = {

71 { -1, 3, 1, 1 },

72 { 3, 0, 0, 0 },

73 { 2, 0, 0, 0 },

74 { 2, 0, 0, 0 },

75 };

77 static const int8_t mv[256][2] = {

78 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },

79 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },

80 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },

81 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },

82 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },

83 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },

84 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },

85 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },

86 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },

87 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },

88 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },

89 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },

90 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },

91 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },

92 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },

93 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },

94 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },

95 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },

96 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },

97 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },

98 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },

99 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },

100 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },

101 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },

102 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },

103 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },

104 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },

105 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },

106 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },

107 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },

108 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },

109 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }

110 };

111

112 /* This is simply the scaled down elementwise product of the standard JPEG

113 * quantizer table and the AAN premul table. */

114 static const uint8_t dequant_table[64] = {

115 16, 15, 13, 19, 24, 31, 28, 17,

116 17, 23, 25, 31, 36, 63, 45, 21,

117 18, 24, 27, 37, 52, 59, 49, 20,

118 16, 28, 34, 40, 60, 80, 51, 20,

119 18, 31, 48, 66, 68, 86, 56, 21,

120 19, 38, 56, 59, 64, 64, 48, 20,

121 27, 48, 55, 55, 56, 51, 35, 15,

122 20, 35, 34, 32, 31, 22, 15, 8,

123 };

124

125 static VLC block_type_vlc[2][4];

126

127

128 typedef struct CFrameBuffer {

129 unsigned int allocated_size;

130 unsigned int size;

131 int id;

132 uint8_t *data;

133 } CFrameBuffer;

134

135 typedef struct FourXContext {

136 AVCodecContext *avctx;

137 BlockDSPContext bdsp;

138 BswapDSPContext bbdsp;

139 uint16_t *frame_buffer;

140 uint16_t *last_frame_buffer;

141 GetBitContext pre_gb; ///< ac/dc prefix

142 GetBitContext gb;

143 GetByteContext g;

144 GetByteContext g2;

145 int mv[256];

146 VLC pre_vlc;

147 int last_dc;

148 DECLARE_ALIGNED(16, int16_t, block)[6][64];

149 void *bitstream_buffer;

150 unsigned int bitstream_buffer_size;

151 int version;

152 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];

153 } FourXContext;

154

155

156 #define FIX_1_082392200 70936

157 #define FIX_1_414213562 92682

158 #define FIX_1_847759065 121095

159 #define FIX_2_613125930 171254

160

161 #define MULTIPLY(var, const) (((var) * (const)) >> 16)

162

163 static void idct(int16_t block[64])

164 {

165 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;

166 int tmp10, tmp11, tmp12, tmp13;

167 int z5, z10, z11, z12, z13;

168 int i;

169 int temp[64];

170

171 for (i = 0; i < 8; i++) {

172 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];

173 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];

174

175 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];

176 tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;

177

178 tmp0 = tmp10 + tmp13;

179 tmp3 = tmp10 - tmp13;

180 tmp1 = tmp11 + tmp12;

181 tmp2 = tmp11 - tmp12;

182

183 z13 = block[8 * 5 + i] + block[8 * 3 + i];

184 z10 = block[8 * 5 + i] - block[8 * 3 + i];

185 z11 = block[8 * 1 + i] + block[8 * 7 + i];

186 z12 = block[8 * 1 + i] - block[8 * 7 + i];

187

188 tmp7 = z11 + z13;

189 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);

190

191 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);

192 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;

193 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;

194

195 tmp6 = tmp12 - tmp7;

196 tmp5 = tmp11 - tmp6;

197 tmp4 = tmp10 + tmp5;

198

199 temp[8 * 0 + i] = tmp0 + tmp7;

200 temp[8 * 7 + i] = tmp0 - tmp7;

201 temp[8 * 1 + i] = tmp1 + tmp6;

202 temp[8 * 6 + i] = tmp1 - tmp6;

203 temp[8 * 2 + i] = tmp2 + tmp5;

204 temp[8 * 5 + i] = tmp2 - tmp5;

205 temp[8 * 4 + i] = tmp3 + tmp4;

206 temp[8 * 3 + i] = tmp3 - tmp4;

207 }

208

209 for (i = 0; i < 8 * 8; i += 8) {

210 tmp10 = temp[0 + i] + temp[4 + i];

211 tmp11 = temp[0 + i] - temp[4 + i];

212

213 tmp13 = temp[2 + i] + temp[6 + i];

214 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;

215

216 tmp0 = tmp10 + tmp13;

217 tmp3 = tmp10 - tmp13;

218 tmp1 = tmp11 + tmp12;

219 tmp2 = tmp11 - tmp12;

220

221 z13 = temp[5 + i] + temp[3 + i];

222 z10 = temp[5 + i] - temp[3 + i];

223 z11 = temp[1 + i] + temp[7 + i];

224 z12 = temp[1 + i] - temp[7 + i];

225

226 tmp7 = z11 + z13;

227 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);

228

229 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);

230 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;

231 tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;

232

233 tmp6 = tmp12 - tmp7;

234 tmp5 = tmp11 - tmp6;

235 tmp4 = tmp10 + tmp5;

236

237 block[0 + i] = (tmp0 + tmp7) >> 6;

238 block[7 + i] = (tmp0 - tmp7) >> 6;

239 block[1 + i] = (tmp1 + tmp6) >> 6;

240 block[6 + i] = (tmp1 - tmp6) >> 6;

241 block[2 + i] = (tmp2 + tmp5) >> 6;

242 block[5 + i] = (tmp2 - tmp5) >> 6;

243 block[4 + i] = (tmp3 + tmp4) >> 6;

244 block[3 + i] = (tmp3 - tmp4) >> 6;

245 }

246 }

247

248 static av_cold void init_vlcs(FourXContext *f)

249 {

250 static VLC_TYPE table[2][4][32][2];

251 int i, j;

252

253 for (i = 0; i < 2; i++) {

254 for (j = 0; j < 4; j++) {

255 block_type_vlc[i][j].table = table[i][j];

256 block_type_vlc[i][j].table_allocated = 32;

257 init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,

258 &block_type_tab[i][j][0][1], 2, 1,

259 &block_type_tab[i][j][0][0], 2, 1,

260 INIT_VLC_USE_NEW_STATIC);

261 }

262 }

263 }

264

265 static void init_mv(FourXContext *f, int linesize)

266 {

267 int i;

268

269 for (i = 0; i < 256; i++) {

270 if (f->version > 1)

271 f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;

272 else

273 f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;

274 }

275 }

276

277 #if HAVE_BIGENDIAN

278 #define LE_CENTRIC_MUL(dst, src, scale, dc) \

279 { \

280 unsigned tmpval = AV_RN32(src); \

281 tmpval = (tmpval << 16) | (tmpval >> 16); \

282 tmpval = tmpval * (scale) + (dc); \

283 tmpval = (tmpval << 16) | (tmpval >> 16); \

284 AV_WN32A(dst, tmpval); \

285 }

286 #else

287 #define LE_CENTRIC_MUL(dst, src, scale, dc) \

288 { \

289 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \

290 AV_WN32A(dst, tmpval); \

291 }

292 #endif

293

294 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,

295 int h, int stride, int scale, unsigned dc)

296 {

297 int i;

298 dc *= 0x10001;

299

300 switch (log2w) {

301 case 0:

302 for (i = 0; i < h; i++) {

303 dst[0] = scale * src[0] + dc;

304 if (scale)

305 src += stride;

306 dst += stride;

307 }

308 break;

309 case 1:

310 for (i = 0; i < h; i++) {

311 LE_CENTRIC_MUL(dst, src, scale, dc);

312 if (scale)

313 src += stride;

314 dst += stride;

315 }

316 break;

317 case 2:

318 for (i = 0; i < h; i++) {

319 LE_CENTRIC_MUL(dst, src, scale, dc);

320 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);

321 if (scale)

322 src += stride;

323 dst += stride;

324 }

325 break;

326 case 3:

327 for (i = 0; i < h; i++) {

328 LE_CENTRIC_MUL(dst, src, scale, dc);

329 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);

330 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);

331 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);

332 if (scale)

333 src += stride;

334 dst += stride;

335 }

336 break;

337 default:

338 av_assert0(0);

339 }

340 }

341

342 static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src,

343 int log2w, int log2h, int stride)

344 {

345 int index, h, code, ret, scale = 1;

346 uint16_t *start, *end;

347 unsigned dc = 0;

348

349 av_assert0(log2w >= 0 && log2h >= 0);

350

351 index = size2index[log2h][log2w];

352 av_assert0(index >= 0);

353

354 h = 1 << log2h;

355 code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,

356 BLOCK_TYPE_VLC_BITS, 1);

357 av_assert0(code >= 0 && code <= 6);

358

359 start = f->last_frame_buffer;

360 end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);

361

362 if (code == 1) {

363 log2h--;

364 if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)

365 return ret;

366 return decode_p_block(f, dst + (stride << log2h),

367 src + (stride << log2h),

368 log2w, log2h, stride);

369 } else if (code == 2) {

370 log2w--;

371 if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)

372 return ret;

373 return decode_p_block(f, dst + (1 << log2w),

374 src + (1 << log2w),

375 log2w, log2h, stride);

376 } else if (code == 6) {

377 if (bytestream2_get_bytes_left(&f->g2) < 4) {

378 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");

379 return AVERROR_INVALIDDATA;

380 }

381 if (log2w) {

382 dst[0] = bytestream2_get_le16u(&f->g2);

383 dst[1] = bytestream2_get_le16u(&f->g2);

384 } else {

385 dst[0] = bytestream2_get_le16u(&f->g2);

386 dst[stride] = bytestream2_get_le16u(&f->g2);

387 }

388 return 0;

389 }

390

391 if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {

392 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");

393 return AVERROR_INVALIDDATA;

394 }

395

396 if (code == 0) {

397 src += f->mv[bytestream2_get_byte(&f->g)];

398 } else if (code == 3 && f->version >= 2) {

399 return 0;

400 } else if (code == 4) {

401 src += f->mv[bytestream2_get_byte(&f->g)];

402 if (bytestream2_get_bytes_left(&f->g2) < 2){

403 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");

404 return AVERROR_INVALIDDATA;

405 }

406 dc = bytestream2_get_le16(&f->g2);

407 } else if (code == 5) {

408 if (bytestream2_get_bytes_left(&f->g2) < 2){

409 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");

410 return AVERROR_INVALIDDATA;

411 }

412 av_assert0(start <= src && src <= end);

413 scale = 0;

414 dc = bytestream2_get_le16(&f->g2);

415 }

416

417 if (start > src || src > end) {

418 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");

419 return AVERROR_INVALIDDATA;

420 }

421

422 mcdc(dst, src, log2w, h, stride, scale, dc);

423

424 return 0;

425 }

426

427 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)

428 {

429 int x, y;

430 const int width = f->avctx->width;

431 const int height = f->avctx->height;

432 uint16_t *dst = f->frame_buffer;

433 uint16_t *src;

434 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,

435 bytestream_offset, wordstream_offset;

436 int ret;

437

438 src = f->last_frame_buffer;

439

440 if (f->version > 1) {

441 extra = 20;

442 if (length < extra)

443 return AVERROR_INVALIDDATA;

444 bitstream_size = AV_RL32(buf + 8);

445 wordstream_size = AV_RL32(buf + 12);

446 bytestream_size = AV_RL32(buf + 16);

447 } else {

448 extra = 0;

449 bitstream_size = AV_RL16(buf - 4);

450 wordstream_size = AV_RL16(buf - 2);

451 bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);

452 }

453

454 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||

455 bytestream_size > length - bitstream_size ||

456 wordstream_size > length - bytestream_size - bitstream_size ||

457 extra > length - bytestream_size - bitstream_size - wordstream_size) {

458 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,

459 bitstream_size+ bytestream_size+ wordstream_size - length);

460 return AVERROR_INVALIDDATA;

461 }

462

463 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,

464 bitstream_size);

465 if (!f->bitstream_buffer)

466 return AVERROR(ENOMEM);

467 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),

468 bitstream_size / 4);

469 init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);

470

471 wordstream_offset = extra + bitstream_size;

472 bytestream_offset = extra + bitstream_size + wordstream_size;

473 bytestream2_init(&f->g2, buf + wordstream_offset,

474 length - wordstream_offset);

475 bytestream2_init(&f->g, buf + bytestream_offset,

476 length - bytestream_offset);

477

478 init_mv(f, width * 2);

479

480 for (y = 0; y < height; y += 8) {

481 for (x = 0; x < width; x += 8)

482 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)

483 return ret;

484 src += 8 * width;

485 dst += 8 * width;

486 }

487

488 return 0;

489 }

490

491 /**

492 * decode block and dequantize.

493 * Note this is almost identical to MJPEG.

494 */

495 static int decode_i_block(FourXContext *f, int16_t *block)

496 {

497 int code, i, j, level, val;

498

499 if (get_bits_left(&f->gb) < 2){

500 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));

501 return -1;

502 }

503

504 /* DC coef */

505 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);

506 if (val >> 4) {

507 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");

508 return AVERROR_INVALIDDATA;

509 }

510

511 if (val)

512 val = get_xbits(&f->gb, val);

513

514 val = val * dequant_table[0] + f->last_dc;

515 f->last_dc = block[0] = val;

516 /* AC coefs */

517 i = 1;

518 for (;;) {

519 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);

520

521 /* EOB */

522 if (code == 0)

523 break;

524 if (code == 0xf0) {

525 i += 16;

526 } else {

527 if (code & 0xf) {

528 level = get_xbits(&f->gb, code & 0xf);

529 } else {

530 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");

531 return AVERROR_INVALIDDATA;

532 }

533 i += code >> 4;

534 if (i >= 64) {

535 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);

536 return 0;

537 }

538

539 j = ff_zigzag_direct[i];

540 block[j] = level * dequant_table[j];

541 i++;

542 if (i >= 64)

543 break;

544 }

545 }

546

547 return 0;

548 }

549

550 static inline void idct_put(FourXContext *f, int x, int y)

551 {

552 int16_t (*block)[64] = f->block;

553 int stride = f->avctx->width;

554 int i;

555 uint16_t *dst = f->frame_buffer + y * stride + x;

556

557 for (i = 0; i < 4; i++) {

558 block[i][0] += 0x80 * 8 * 8;

559 idct(block[i]);

560 }

561

562 if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {

563 for (i = 4; i < 6; i++)

564 idct(block[i]);

565 }

566

567 /* Note transform is:

568 * y = ( 1b + 4g + 2r) / 14

569 * cb = ( 3b - 2g - 1r) / 14

570 * cr = (-1b - 4g + 5r) / 14 */

571 for (y = 0; y < 8; y++) {

572 for (x = 0; x < 8; x++) {

573 int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +

574 2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize

575 int cb = block[4][x + 8 * y];

576 int cr = block[5][x + 8 * y];

577 int cg = (cb + cr) >> 1;

578 int y;

579

580 cb += cb;

581

582 y = temp[0];

583 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);

584 y = temp[1];

585 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);

586 y = temp[8];

587 dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);

588 y = temp[9];

589 dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);

590 dst += 2;

591 }

592 dst += 2 * stride - 2 * 8;

593 }

594 }

595

596 static int decode_i_mb(FourXContext *f)

597 {

598 int ret;

599 int i;

600

601 f->bdsp.clear_blocks(f->block[0]);

602

603 for (i = 0; i < 6; i++)

604 if ((ret = decode_i_block(f, f->block[i])) < 0)

605 return ret;

606

607 return 0;

608 }

609

610 static const uint8_t *read_huffman_tables(FourXContext *f,

611 const uint8_t * const buf,

612 int buf_size)

613 {

614 int frequency[512] = { 0 };

615 uint8_t flag[512];

616 int up[512];

617 uint8_t len_tab[257];

618 int bits_tab[257];

619 int start, end;

620 const uint8_t *ptr = buf;

621 const uint8_t *ptr_end = buf + buf_size;

622 int j;

623

624 memset(up, -1, sizeof(up));

625

626 start = *ptr++;

627 end = *ptr++;

628 for (;;) {

629 int i;

630

631 if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {

632 av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");

633 return NULL;

634 }

635

636 for (i = start; i <= end; i++)

637 frequency[i] = *ptr++;

638 start = *ptr++;

639 if (start == 0)

640 break;

641

642 end = *ptr++;

643 }

644 frequency[256] = 1;

645

646 while ((ptr - buf) & 3)

647 ptr++; // 4byte align

648

649 if (ptr > ptr_end) {

650 av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");

651 return NULL;

652 }

653

654 for (j = 257; j < 512; j++) {

655 int min_freq[2] = { 256 * 256, 256 * 256 };

656 int smallest[2] = { 0, 0 };

657 int i;

658 for (i = 0; i < j; i++) {

659 if (frequency[i] == 0)

660 continue;

661 if (frequency[i] < min_freq[1]) {

662 if (frequency[i] < min_freq[0]) {

663 min_freq[1] = min_freq[0];

664 smallest[1] = smallest[0];

665 min_freq[0] = frequency[i];

666 smallest[0] = i;

667 } else {

668 min_freq[1] = frequency[i];

669 smallest[1] = i;

670 }

671 }

672 }

673 if (min_freq[1] == 256 * 256)

674 break;

675

676 frequency[j] = min_freq[0] + min_freq[1];

677 flag[smallest[0]] = 0;

678 flag[smallest[1]] = 1;

679 up[smallest[0]] =

680 up[smallest[1]] = j;

681 frequency[smallest[0]] = frequency[smallest[1]] = 0;

682 }

683

684 for (j = 0; j < 257; j++) {

685 int node, len = 0, bits = 0;

686

687 for (node = j; up[node] != -1; node = up[node]) {

688 bits += flag[node] << len;

689 len++;

690 if (len > 31)

691 // can this happen at all ?

692 av_log(f->avctx, AV_LOG_ERROR,

693 "vlc length overflow\n");

694 }

695

696 bits_tab[j] = bits;

697 len_tab[j] = len;

698 }

699

700 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,

701 bits_tab, 4, 4, 0))

702 return NULL;

703

704 return ptr;

705 }

706

707 static int mix(int c0, int c1)

708 {

709 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);

710 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;

711 int red = 2 * (c0 >> 10) + (c1 >> 10);

712 return red / 3 * 1024 + green / 3 * 32 + blue / 3;

713 }

714

715 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)

716 {

717 int x, y, x2, y2;

718 const int width = f->avctx->width;

719 const int height = f->avctx->height;

720 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);

721 uint16_t *dst = f->frame_buffer;

722 const uint8_t *buf_end = buf + length;

723 GetByteContext g3;

724

725 if (length < mbs * 8) {

726 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");

727 return AVERROR_INVALIDDATA;

728 }

729 bytestream2_init(&g3, buf, length);

730

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

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

733 unsigned int color[4] = { 0 }, bits;

734 if (buf_end - buf < 8)

735 return -1;

736 // warning following is purely guessed ...

737 color[0] = bytestream2_get_le16u(&g3);

738 color[1] = bytestream2_get_le16u(&g3);

739

740 if (color[0] & 0x8000)

741 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");

742 if (color[1] & 0x8000)

743 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");

744

745 color[2] = mix(color[0], color[1]);

746 color[3] = mix(color[1], color[0]);

747

748 bits = bytestream2_get_le32u(&g3);

749 for (y2 = 0; y2 < 16; y2++) {

750 for (x2 = 0; x2 < 16; x2++) {

751 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);

752 dst[y2 * width + x2] = color[(bits >> index) & 3];

753 }

754 }

755 dst += 16;

756 }

757 dst += 16 * width - x;

758 }

759

760 return 0;

761 }

762

763 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)

764 {

765 int x, y, ret;

766 const int width = f->avctx->width;

767 const int height = f->avctx->height;

768 const unsigned int bitstream_size = AV_RL32(buf);

769 unsigned int prestream_size;

770 const uint8_t *prestream;

771

772 if (bitstream_size > (1 << 26))

773 return AVERROR_INVALIDDATA;

774

775 if (length < bitstream_size + 12) {

776 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");

777 return AVERROR_INVALIDDATA;

778 }

779

780 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);

781 prestream = buf + bitstream_size + 12;

782

783 if (prestream_size + bitstream_size + 12 != length

784 || prestream_size > (1 << 26)) {

785 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",

786 prestream_size, bitstream_size, length);

787 return AVERROR_INVALIDDATA;

788 }

789

790 prestream = read_huffman_tables(f, prestream, prestream_size);

791 if (!prestream) {

792 av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");

793 return AVERROR_INVALIDDATA;

794 }

795

796 av_assert0(prestream <= buf + length);

797

798 init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);

799

800 prestream_size = length + buf - prestream;

801

802 av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,

803 prestream_size);

804 if (!f->bitstream_buffer)

805 return AVERROR(ENOMEM);

806 f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,

807 prestream_size / 4);

808 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);

809

810 f->last_dc = 0 * 128 * 8 * 8;

811

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

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

814 if ((ret = decode_i_mb(f)) < 0)

815 return ret;

816

817 idct_put(f, x, y);

818 }

819 }

820

821 if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)

822 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");

823

824 return 0;

825 }

826

827 static int decode_frame(AVCodecContext *avctx, void *data,

828 int *got_frame, AVPacket *avpkt)

829 {

830 const uint8_t *buf = avpkt->data;

831 int buf_size = avpkt->size;

832 FourXContext *const f = avctx->priv_data;

833 AVFrame *picture = data;

834 int i, frame_4cc, frame_size, ret;

835

836 if (buf_size < 20)

837 return AVERROR_INVALIDDATA;

838

839 av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);

840

841 if (buf_size < AV_RL32(buf + 4) + 8) {

842 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",

843 buf_size, AV_RL32(buf + 4));

844 return AVERROR_INVALIDDATA;

845 }

846

847 frame_4cc = AV_RL32(buf);

848

849 if (frame_4cc == AV_RL32("cfrm")) {

850 int free_index = -1;

851 int id, whole_size;

852 const int data_size = buf_size - 20;

853 CFrameBuffer *cfrm;

854

855 if (f->version <= 1) {

856 av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);

857 return AVERROR_INVALIDDATA;

858 }

859

860 id = AV_RL32(buf + 12);

861 whole_size = AV_RL32(buf + 16);

862

863 if (data_size < 0 || whole_size < 0) {

864 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");

865 return AVERROR_INVALIDDATA;

866 }

867

868 for (i = 0; i < CFRAME_BUFFER_COUNT; i++)

869 if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)

870 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",

871 f->cfrm[i].id);

872

873 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {

874 if (f->cfrm[i].id == id)

875 break;

876 if (f->cfrm[i].size == 0)

877 free_index = i;

878 }

879

880 if (i >= CFRAME_BUFFER_COUNT) {

881 i = free_index;

882 f->cfrm[i].id = id;

883 }

884 cfrm = &f->cfrm[i];

885

886 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)

887 return AVERROR_INVALIDDATA;

888

889 cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,

890 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);

891 // explicit check needed as memcpy below might not catch a NULL

892 if (!cfrm->data) {

893 av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");

894 return AVERROR(ENOMEM);

895 }

896

897 memcpy(cfrm->data + cfrm->size, buf + 20, data_size);

898 cfrm->size += data_size;

899

900 if (cfrm->size >= whole_size) {

901 buf = cfrm->data;

902 frame_size = cfrm->size;

903

904 if (id != avctx->frame_number)

905 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",

906 id, avctx->frame_number);

907

908 if (f->version <= 1)

909 return AVERROR_INVALIDDATA;

910

911 cfrm->size = cfrm->id = 0;

912 frame_4cc = AV_RL32("pfrm");

913 } else

914 return buf_size;

915 } else {

916 buf = buf + 12;

917 frame_size = buf_size - 12;

918 }

919

920 if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)

921 return ret;

922

923 if (frame_4cc == AV_RL32("ifr2")) {

924 picture->pict_type = AV_PICTURE_TYPE_I;

925 if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {

926 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");

927 return ret;

928 }

929 } else if (frame_4cc == AV_RL32("ifrm")) {

930 picture->pict_type = AV_PICTURE_TYPE_I;

931 if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {

932 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");

933 return ret;

934 }

935 } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {

936 picture->pict_type = AV_PICTURE_TYPE_P;

937 if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {

938 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");

939 return ret;

940 }

941 } else if (frame_4cc == AV_RL32("snd_")) {

942 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",

943 buf_size);

944 } else {

945 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",

946 buf_size);

947 }

948

949 picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;

950

951 av_image_copy_plane(picture->data[0], picture->linesize[0],

952 (const uint8_t*)f->frame_buffer, avctx->width * 2,

953 avctx->width * 2, avctx->height);

954 FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);

955

956 *got_frame = 1;

957

958 emms_c();

959

960 return buf_size;

961 }

962

963 static av_cold int decode_end(AVCodecContext *avctx)

964 {

965 FourXContext * const f = avctx->priv_data;

966 int i;

967

968 av_freep(&f->frame_buffer);

969 av_freep(&f->last_frame_buffer);

970 av_freep(&f->bitstream_buffer);

971 f->bitstream_buffer_size = 0;

972 for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {

973 av_freep(&f->cfrm[i].data);

974 f->cfrm[i].allocated_size = 0;

975 }

976 ff_free_vlc(&f->pre_vlc);

977

978 return 0;

979 }

980

981 static av_cold int decode_init(AVCodecContext *avctx)

982 {

983 FourXContext * const f = avctx->priv_data;

984 int ret;

985

986 if (avctx->extradata_size != 4 || !avctx->extradata) {

987 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");

988 return AVERROR_INVALIDDATA;

989 }

990 if((avctx->width % 16) || (avctx->height % 16)) {

991 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");

992 return AVERROR_INVALIDDATA;

993 }

994

995 ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);

996 if (ret < 0)

997 return ret;

998

999 f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);

1000 f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);

1001 if (!f->frame_buffer || !f->last_frame_buffer) {

1002 decode_end(avctx);

1003 return AVERROR(ENOMEM);

1004 }

1005

1006 f->version = AV_RL32(avctx->extradata) >> 16;

1007 ff_blockdsp_init(&f->bdsp, avctx);

1008 ff_bswapdsp_init(&f->bbdsp);

1009 f->avctx = avctx;

1010 init_vlcs(f);

1011

1012 if (f->version > 2)

1013 avctx->pix_fmt = AV_PIX_FMT_RGB565;

1014 else

1015 avctx->pix_fmt = AV_PIX_FMT_BGR555;

1016

1017 return 0;

1018 }

1019

1020 AVCodec ff_fourxm_decoder = {

1021 .name = "4xm",

1022 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),

1023 .type = AVMEDIA_TYPE_VIDEO,

1024 .id = AV_CODEC_ID_4XM,

1025 .priv_data_size = sizeof(FourXContext),

1026 .init = decode_init,

1027 .close = decode_end,

1028 .decode = decode_frame,

1029 .capabilities = CODEC_CAP_DR1,

1030 };

Generated on Sun Mar 8 2015 02:34:46 for FFmpeg by doxygen 1.8.2