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 "libavutil/avassert.h"

28 #include "libavutil/frame.h"

29 #include "libavutil/intreadwrite.h"

30 #include "avcodec.h"

31 #include "bytestream.h"

32 #include "dsputil.h"

33 #include "get_bits.h"

34 #include "internal.h"

37 #define BLOCK_TYPE_VLC_BITS 5

38 #define ACDC_VLC_BITS 9

40 #define CFRAME_BUFFER_COUNT 100

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

43 {

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

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

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

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

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

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

50 }, { // 1 x 2, 2 x 1

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

52 }

53 }, {

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

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

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

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

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

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

60 }, {// 1 x 2, 2 x 1

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

62 }

63 }

64 };

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

67 { -1, 3, 1, 1 },

68 { 3, 0, 0, 0 },

69 { 2, 0, 0, 0 },

70 { 2, 0, 0, 0 },

71 };

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

74 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },

75 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },

76 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },

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

78 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },

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

80 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },

81 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },

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

83 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

106 };

107

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

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

110 static const uint8_t dequant_table[64] = {

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

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

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

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

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

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

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

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

119 };

120

121 static VLC block_type_vlc[2][4];

122

123

124 typedef struct CFrameBuffer {

125 unsigned int allocated_size;

126 unsigned int size;

127 int id;

128 uint8_t *data;

129 } CFrameBuffer;

130

131 typedef struct FourXContext {

132 AVCodecContext *avctx;

133 DSPContext dsp;

134 AVFrame *current_picture, *last_picture;

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

136 GetBitContext gb;

137 GetByteContext g;

138 GetByteContext g2;

139 int mv[256];

140 VLC pre_vlc;

141 int last_dc;

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

143 void *bitstream_buffer;

144 unsigned int bitstream_buffer_size;

145 int version;

146 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];

147 } FourXContext;

148

149

150 #define FIX_1_082392200 70936

151 #define FIX_1_414213562 92682

152 #define FIX_1_847759065 121095

153 #define FIX_2_613125930 171254

154

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

156

157 static void idct(int16_t block[64])

158 {

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

160 int tmp10, tmp11, tmp12, tmp13;

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

162 int i;

163 int temp[64];

164

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

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

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

168

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

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

171

172 tmp0 = tmp10 + tmp13;

173 tmp3 = tmp10 - tmp13;

174 tmp1 = tmp11 + tmp12;

175 tmp2 = tmp11 - tmp12;

176

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

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

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

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

181

182 tmp7 = z11 + z13;

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

184

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

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

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

188

189 tmp6 = tmp12 - tmp7;

190 tmp5 = tmp11 - tmp6;

191 tmp4 = tmp10 + tmp5;

192

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

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

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

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

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

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

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

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

201 }

202

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

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

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

206

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

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

209

210 tmp0 = tmp10 + tmp13;

211 tmp3 = tmp10 - tmp13;

212 tmp1 = tmp11 + tmp12;

213 tmp2 = tmp11 - tmp12;

214

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

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

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

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

219

220 tmp7 = z11 + z13;

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

222

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

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

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

226

227 tmp6 = tmp12 - tmp7;

228 tmp5 = tmp11 - tmp6;

229 tmp4 = tmp10 + tmp5;

230

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

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

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

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

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

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

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

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

239 }

240 }

241

242 static av_cold void init_vlcs(FourXContext *f)

243 {

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

245 int i, j;

246

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

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

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

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

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

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

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

254 INIT_VLC_USE_NEW_STATIC);

255 }

256 }

257 }

258

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

260 {

261 int i;

262

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

264 if (f->version > 1)

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

266 else

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

268 }

269 }

270

271 #if HAVE_BIGENDIAN

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

273 { \

274 unsigned tmpval = AV_RN32(src); \

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

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

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

278 AV_WN32A(dst, tmpval); \

279 }

280 #else

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

282 { \

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

284 AV_WN32A(dst, tmpval); \

285 }

286 #endif

287

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

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

290 {

291 int i;

292 dc *= 0x10001;

293

294 switch (log2w) {

295 case 0:

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

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

298 if (scale)

299 src += stride;

300 dst += stride;

301 }

302 break;

303 case 1:

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

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

306 if (scale)

307 src += stride;

308 dst += stride;

309 }

310 break;

311 case 2:

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

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

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

315 if (scale)

316 src += stride;

317 dst += stride;

318 }

319 break;

320 case 3:

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

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

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

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

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

326 if (scale)

327 src += stride;

328 dst += stride;

329 }

330 break;

331 default:

332 av_assert0(0);

333 }

334 }

335

336 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,

337 int log2w, int log2h, int stride)

338 {

339 const int index = size2index[log2h][log2w];

340 const int h = 1 << log2h;

341 int code = get_vlc2(&f->gb,

342 block_type_vlc[1 - (f->version > 1)][index].table,

343 BLOCK_TYPE_VLC_BITS, 1);

344 uint16_t *start = (uint16_t *)f->last_picture->data[0];

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

346 int ret;

347 int scale = 1;

348 unsigned dc = 0;

349

350 av_assert0(code >= 0 && code <= 6 && log2w >= 0);

351

352 if (code == 1) {

353 log2h--;

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

355 return ret;

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

357 src + (stride << log2h),

358 log2w, log2h, stride);

359 } else if (code == 2) {

360 log2w--;

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

362 return ret;

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

364 src + (1 << log2w),

365 log2w, log2h, stride);

366 } else if (code == 6) {

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

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

369 return AVERROR_INVALIDDATA;

370 }

371 if (log2w) {

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

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

374 } else {

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

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

377 }

378 return 0;

379 }

380

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

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

383 return AVERROR_INVALIDDATA;

384 }

385

386 if (code == 0) {

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

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

389 return 0;

390 } else if (code == 4) {

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

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

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

394 return AVERROR_INVALIDDATA;

395 }

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

397 } else if (code == 5) {

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

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

400 return AVERROR_INVALIDDATA;

401 }

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

403 scale = 0;

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

405 }

406

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

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

409 return AVERROR_INVALIDDATA;

410 }

411

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

413

414 return 0;

415 }

416

417 static int decode_p_frame(FourXContext *f, AVFrame *frame,

418 const uint8_t *buf, int length)

419 {

420 int x, y;

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

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

423 uint16_t *dst = (uint16_t *)frame->data[0];

424 const int stride = frame->linesize[0] >> 1;

425 uint16_t *src;

426 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,

427 bytestream_offset, wordstream_offset;

428 int ret;

429

430 if (!f->last_picture->data[0]) {

431 if ((ret = ff_get_buffer(f->avctx, f->last_picture,

432 AV_GET_BUFFER_FLAG_REF)) < 0) {

433 return ret;

434 }

435 for (y=0; y<f->avctx->height; y++)

436 memset(f->last_picture->data[0] + y*f->last_picture->linesize[0], 0, 2*f->avctx->width);

437 }

438

439 src = (uint16_t *)f->last_picture->data[0];

440

441 if (f->version > 1) {

442 extra = 20;

443 if (length < extra)

444 return AVERROR_INVALIDDATA;

445 bitstream_size = AV_RL32(buf + 8);

446 wordstream_size = AV_RL32(buf + 12);

447 bytestream_size = AV_RL32(buf + 16);

448 } else {

449 extra = 0;

450 bitstream_size = AV_RL16(buf - 4);

451 wordstream_size = AV_RL16(buf - 2);

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

453 }

454

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

456 bytestream_size > length - bitstream_size ||

457 wordstream_size > length - bytestream_size - bitstream_size ||

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

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

460 bitstream_size+ bytestream_size+ wordstream_size - length);

461 return AVERROR_INVALIDDATA;

462 }

463

464 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,

465 bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);

466 if (!f->bitstream_buffer)

467 return AVERROR(ENOMEM);

468 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),

469 bitstream_size / 4);

470 memset((uint8_t*)f->bitstream_buffer + bitstream_size,

471 0, FF_INPUT_BUFFER_PADDING_SIZE);

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

473

474 wordstream_offset = extra + bitstream_size;

475 bytestream_offset = extra + bitstream_size + wordstream_size;

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

477 length - wordstream_offset);

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

479 length - bytestream_offset);

480

481 init_mv(f, frame->linesize[0]);

482

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

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

485 if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)

486 return ret;

487 src += 8 * stride;

488 dst += 8 * stride;

489 }

490

491 return 0;

492 }

493

494 /**

495 * decode block and dequantize.

496 * Note this is almost identical to MJPEG.

497 */

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

499 {

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

501

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

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

504 return -1;

505 }

506

507 /* DC coef */

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

509 if (val >> 4) {

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

511 return AVERROR_INVALIDDATA;

512 }

513

514 if (val)

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

516

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

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

519 /* AC coefs */

520 i = 1;

521 for (;;) {

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

523

524 /* EOB */

525 if (code == 0)

526 break;

527 if (code == 0xf0) {

528 i += 16;

529 } else {

530 if (code & 0xf) {

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

532 } else {

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

534 return AVERROR_INVALIDDATA;

535 }

536 i += code >> 4;

537 if (i >= 64) {

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

539 return 0;

540 }

541

542 j = ff_zigzag_direct[i];

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

544 i++;

545 if (i >= 64)

546 break;

547 }

548 }

549

550 return 0;

551 }

552

553 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)

554 {

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

556 int stride = frame->linesize[0] >> 1;

557 int i;

558 uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;

559

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

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

562 idct(block[i]);

563 }

564

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

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

567 idct(block[i]);

568 }

569

570 /* Note transform is:

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

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

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

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

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

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

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

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

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

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

581 int y;

582

583 cb += cb;

584

585 y = temp[0];

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

587 y = temp[1];

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

589 y = temp[8];

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

591 y = temp[9];

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

593 dst += 2;

594 }

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

596 }

597 }

598

599 static int decode_i_mb(FourXContext *f)

600 {

601 int ret;

602 int i;

603

604 f->dsp.clear_blocks(f->block[0]);

605

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

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

608 return ret;

609

610 return 0;

611 }

612

613 static const uint8_t *read_huffman_tables(FourXContext *f,

614 const uint8_t * const buf,

615 int buf_size)

616 {

617 int frequency[512] = { 0 };

618 uint8_t flag[512];

619 int up[512];

620 uint8_t len_tab[257];

621 int bits_tab[257];

622 int start, end;

623 const uint8_t *ptr = buf;

624 const uint8_t *ptr_end = buf + buf_size;

625 int j;

626

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

628

629 start = *ptr++;

630 end = *ptr++;

631 for (;;) {

632 int i;

633

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

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

636 return NULL;

637 }

638

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

640 frequency[i] = *ptr++;

641 start = *ptr++;

642 if (start == 0)

643 break;

644

645 end = *ptr++;

646 }

647 frequency[256] = 1;

648

649 while ((ptr - buf) & 3)

650 ptr++; // 4byte align

651

652 if (ptr > ptr_end) {

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

654 return NULL;

655 }

656

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

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

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

660 int i;

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

662 if (frequency[i] == 0)

663 continue;

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

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

666 min_freq[1] = min_freq[0];

667 smallest[1] = smallest[0];

668 min_freq[0] = frequency[i];

669 smallest[0] = i;

670 } else {

671 min_freq[1] = frequency[i];

672 smallest[1] = i;

673 }

674 }

675 }

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

677 break;

678

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

680 flag[smallest[0]] = 0;

681 flag[smallest[1]] = 1;

682 up[smallest[0]] =

683 up[smallest[1]] = j;

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

685 }

686

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

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

689

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

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

692 len++;

693 if (len > 31)

694 // can this happen at all ?

695 av_log(f->avctx, AV_LOG_ERROR,

696 "vlc length overflow\n");

697 }

698

699 bits_tab[j] = bits;

700 len_tab[j] = len;

701 }

702

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

704 bits_tab, 4, 4, 0))

705 return NULL;

706

707 return ptr;

708 }

709

710 static int mix(int c0, int c1)

711 {

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

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

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

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

716 }

717

718 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)

719 {

720 int x, y, x2, y2;

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

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

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

724 uint16_t *dst = (uint16_t*)frame->data[0];

725 const int stride = frame->linesize[0]>>1;

726 const uint8_t *buf_end = buf + length;

727 GetByteContext g3;

728

729 if (length < mbs * 8) {

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

731 return AVERROR_INVALIDDATA;

732 }

733 bytestream2_init(&g3, buf, length);

734

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

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

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

738 if (buf_end - buf < 8)

739 return -1;

740 // warning following is purely guessed ...

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

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

743

744 if (color[0] & 0x8000)

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

746 if (color[1] & 0x8000)

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

748

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

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

751

752 bits = bytestream2_get_le32u(&g3);

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

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

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

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

757 }

758 }

759 dst += 16;

760 }

761 dst += 16 * stride - x;

762 }

763

764 return 0;

765 }

766

767 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)

768 {

769 int x, y, ret;

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

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

772 const unsigned int bitstream_size = AV_RL32(buf);

773 unsigned int prestream_size;

774 const uint8_t *prestream;

775

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

777 return AVERROR_INVALIDDATA;

778

779 if (length < bitstream_size + 12) {

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

781 return AVERROR_INVALIDDATA;

782 }

783

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

785 prestream = buf + bitstream_size + 12;

786

787 if (prestream_size + bitstream_size + 12 != length

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

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

790 prestream_size, bitstream_size, length);

791 return AVERROR_INVALIDDATA;

792 }

793

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

795 if (!prestream) {

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

797 return AVERROR_INVALIDDATA;

798 }

799

800 av_assert0(prestream <= buf + length);

801

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

803

804 prestream_size = length + buf - prestream;

805

806 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,

807 prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);

808 if (!f->bitstream_buffer)

809 return AVERROR(ENOMEM);

810 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,

811 prestream_size / 4);

812 memset((uint8_t*)f->bitstream_buffer + prestream_size,

813 0, FF_INPUT_BUFFER_PADDING_SIZE);

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

815

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

817

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

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

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

821 return ret;

822

823 idct_put(f, frame, x, y);

824 }

825 }

826

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

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

829

830 return 0;

831 }

832

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

834 int *got_frame, AVPacket *avpkt)

835 {

836 const uint8_t *buf = avpkt->data;

837 int buf_size = avpkt->size;

838 FourXContext *const f = avctx->priv_data;

839 AVFrame *picture = data;

840 int i, frame_4cc, frame_size, ret;

841

842 if (buf_size < 20)

843 return AVERROR_INVALIDDATA;

844

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

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

847 buf_size, AV_RL32(buf + 4));

848 return AVERROR_INVALIDDATA;

849 }

850

851 frame_4cc = AV_RL32(buf);

852

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

854 int free_index = -1;

855 int id, whole_size;

856 const int data_size = buf_size - 20;

857 CFrameBuffer *cfrm;

858

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

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

861 return AVERROR_INVALIDDATA;

862 }

863

864 id = AV_RL32(buf + 12);

865 whole_size = AV_RL32(buf + 16);

866

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

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

869 return AVERROR_INVALIDDATA;

870 }

871

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

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

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

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

876

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

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

879 break;

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

881 free_index = i;

882 }

883

884 if (i >= CFRAME_BUFFER_COUNT) {

885 i = free_index;

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

887 }

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

889

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

891 return AVERROR_INVALIDDATA;

892

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

894 cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);

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

896 if (!cfrm->data) {

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

898 return AVERROR(ENOMEM);

899 }

900

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

902 cfrm->size += data_size;

903

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

905 buf = cfrm->data;

906 frame_size = cfrm->size;

907

908 if (id != avctx->frame_number)

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

910 id, avctx->frame_number);

911

912 if (f->version <= 1)

913 return AVERROR_INVALIDDATA;

914

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

916 frame_4cc = AV_RL32("pfrm");

917 } else

918 return buf_size;

919 } else {

920 buf = buf + 12;

921 frame_size = buf_size - 12;

922 }

923

924 FFSWAP(AVFrame*, f->current_picture, f->last_picture);

925

926 // alternatively we would have to use our own buffer management

927 avctx->flags |= CODEC_FLAG_EMU_EDGE;

928

929 if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)

930 return ret;

931

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

933 f->current_picture->pict_type = AV_PICTURE_TYPE_I;

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

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

936 return ret;

937 }

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

939 f->current_picture->pict_type = AV_PICTURE_TYPE_I;

940 if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {

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

942 return ret;

943 }

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

945 f->current_picture->pict_type = AV_PICTURE_TYPE_P;

946 if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {

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

948 return ret;

949 }

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

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

952 buf_size);

953 } else {

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

955 buf_size);

956 }

957

958 f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;

959

960 if ((ret = av_frame_ref(picture, f->current_picture)) < 0)

961 return ret;

962 *got_frame = 1;

963

964 emms_c();

965

966 return buf_size;

967 }

968

969 static av_cold int decode_init(AVCodecContext *avctx)

970 {

971 FourXContext * const f = avctx->priv_data;

972

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

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

975 return AVERROR_INVALIDDATA;

976 }

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

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

979 return AVERROR_INVALIDDATA;

980 }

981

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

983 ff_dsputil_init(&f->dsp, avctx);

984 f->avctx = avctx;

985 init_vlcs(f);

986

987 if (f->version > 2)

988 avctx->pix_fmt = AV_PIX_FMT_RGB565;

989 else

990 avctx->pix_fmt = AV_PIX_FMT_BGR555;

991

992 f->current_picture = av_frame_alloc();

993 f->last_picture = av_frame_alloc();

994 if (!f->current_picture || !f->last_picture)

995 return AVERROR(ENOMEM);

996

997 return 0;

998 }

999

1000

1001 static av_cold int decode_end(AVCodecContext *avctx)

1002 {

1003 FourXContext * const f = avctx->priv_data;

1004 int i;

1005

1006 av_freep(&f->bitstream_buffer);

1007 f->bitstream_buffer_size = 0;

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

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

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

1011 }

1012 ff_free_vlc(&f->pre_vlc);

1013 av_frame_free(&f->current_picture);

1014 av_frame_free(&f->last_picture);

1015

1016 return 0;

1017 }

1018

1019 AVCodec ff_fourxm_decoder = {

1020 .name = "4xm",

1021 .type = AVMEDIA_TYPE_VIDEO,

1022 .id = AV_CODEC_ID_4XM,

1023 .priv_data_size = sizeof(FourXContext),

1024 .init = decode_init,

1025 .close = decode_end,

1026 .decode = decode_frame,

1027 .capabilities = CODEC_CAP_DR1,

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

1029 };

Generated on Wed Jul 10 2013 23:47:53 for FFmpeg by doxygen 1.8.2