FFmpeg: libavcodec/dsicinav.c Source File

FFmpeg

[フレーム]

libavcodec

dsicinav.c

Go to the documentation of this file.

1 /*

2 * Delphine Software International CIN Audio/Video Decoders

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 * Delphine Software International CIN audio/video decoders

25 */

27 #include "libavutil/channel_layout.h"

28 #include "avcodec.h"

29 #include "bytestream.h"

30 #include "internal.h"

31 #include "mathops.h"

34 typedef enum CinVideoBitmapIndex {

35 CIN_CUR_BMP = 0, /* current */

36 CIN_PRE_BMP = 1, /* previous */

37 CIN_INT_BMP = 2 /* intermediate */

38 } CinVideoBitmapIndex;

40 typedef struct CinVideoContext {

41 AVCodecContext *avctx;

42 AVFrame *frame;

43 unsigned int bitmap_size;

44 uint32_t palette[256];

45 uint8_t *bitmap_table[3];

46 } CinVideoContext;

48 typedef struct CinAudioContext {

49 int initial_decode_frame;

50 int delta;

51 } CinAudioContext;

54 /* table defining a geometric sequence with multiplier = 32767 ^ (1 / 128) */

55 static const int16_t cinaudio_delta16_table[256] = {

56 0, 0, 0, 0, 0, 0, 0, 0,

57 0, 0, 0, 0, 0, 0, 0, 0,

58 0, 0, 0, -30210, -27853, -25680, -23677, -21829,

59 -20126, -18556, -17108, -15774, -14543, -13408, -12362, -11398,

60 -10508, -9689, -8933, -8236, -7593, -7001, -6455, -5951,

61 -5487, -5059, -4664, -4300, -3964, -3655, -3370, -3107,

62 -2865, -2641, -2435, -2245, -2070, -1908, -1759, -1622,

63 -1495, -1379, -1271, -1172, -1080, -996, -918, -847,

64 -781, -720, -663, -612, -564, -520, -479, -442,

65 -407, -376, -346, -319, -294, -271, -250, -230,

66 -212, -196, -181, -166, -153, -141, -130, -120,

67 -111, -102, -94, -87, -80, -74, -68, -62,

68 -58, -53, -49, -45, -41, -38, -35, -32,

69 -30, -27, -25, -23, -21, -20, -18, -17,

70 -15, -14, -13, -12, -11, -10, -9, -8,

71 -7, -6, -5, -4, -3, -2, -1, 0,

72 0, 1, 2, 3, 4, 5, 6, 7,

73 8, 9, 10, 11, 12, 13, 14, 15,

74 17, 18, 20, 21, 23, 25, 27, 30,

75 32, 35, 38, 41, 45, 49, 53, 58,

76 62, 68, 74, 80, 87, 94, 102, 111,

77 120, 130, 141, 153, 166, 181, 196, 212,

78 230, 250, 271, 294, 319, 346, 376, 407,

79 442, 479, 520, 564, 612, 663, 720, 781,

80 847, 918, 996, 1080, 1172, 1271, 1379, 1495,

81 1622, 1759, 1908, 2070, 2245, 2435, 2641, 2865,

82 3107, 3370, 3655, 3964, 4300, 4664, 5059, 5487,

83 5951, 6455, 7001, 7593, 8236, 8933, 9689, 10508,

84 11398, 12362, 13408, 14543, 15774, 17108, 18556, 20126,

85 21829, 23677, 25680, 27853, 30210, 0, 0, 0,

86 0, 0, 0, 0, 0, 0, 0, 0,

87 0, 0, 0, 0, 0, 0, 0, 0

88 };

90 static av_cold void destroy_buffers(CinVideoContext *cin)

91 {

92 int i;

94 for (i = 0; i < 3; ++i)

95 av_freep(&cin->bitmap_table[i]);

96 }

98 static av_cold int allocate_buffers(CinVideoContext *cin)

99 {

100 int i;

101

102 for (i = 0; i < 3; ++i) {

103 cin->bitmap_table[i] = av_mallocz(cin->bitmap_size);

104 if (!cin->bitmap_table[i]) {

105 av_log(cin->avctx, AV_LOG_ERROR, "Can't allocate bitmap buffers.\n");

106 destroy_buffers(cin);

107 return AVERROR(ENOMEM);

108 }

109 }

110

111 return 0;

112 }

113

114 static av_cold int cinvideo_decode_init(AVCodecContext *avctx)

115 {

116 CinVideoContext *cin = avctx->priv_data;

117

118 cin->avctx = avctx;

119 avctx->pix_fmt = AV_PIX_FMT_PAL8;

120

121 cin->frame = av_frame_alloc();

122 if (!cin->frame)

123 return AVERROR(ENOMEM);

124

125 cin->bitmap_size = avctx->width * avctx->height;

126 if (allocate_buffers(cin))

127 return AVERROR(ENOMEM);

128

129 return 0;

130 }

131

132 static void cin_apply_delta_data(const unsigned char *src, unsigned char *dst,

133 int size)

134 {

135 while (size--)

136 *dst++ += *src++;

137 }

138

139 static int cin_decode_huffman(const unsigned char *src, int src_size,

140 unsigned char *dst, int dst_size)

141 {

142 int b, huff_code = 0;

143 unsigned char huff_code_table[15];

144 unsigned char *dst_cur = dst;

145 unsigned char *dst_end = dst + dst_size;

146 const unsigned char *src_end = src + src_size;

147

148 memcpy(huff_code_table, src, 15);

149 src += 15;

150

151 while (src < src_end) {

152 huff_code = *src++;

153 if ((huff_code >> 4) == 15) {

154 b = huff_code << 4;

155 huff_code = *src++;

156 *dst_cur++ = b | (huff_code >> 4);

157 } else

158 *dst_cur++ = huff_code_table[huff_code >> 4];

159 if (dst_cur >= dst_end)

160 break;

161

162 huff_code &= 15;

163 if (huff_code == 15) {

164 *dst_cur++ = *src++;

165 } else

166 *dst_cur++ = huff_code_table[huff_code];

167 if (dst_cur >= dst_end)

168 break;

169 }

170

171 return dst_cur - dst;

172 }

173

174 static int cin_decode_lzss(const unsigned char *src, int src_size,

175 unsigned char *dst, int dst_size)

176 {

177 uint16_t cmd;

178 int i, sz, offset, code;

179 unsigned char *dst_end = dst + dst_size, *dst_start = dst;

180 const unsigned char *src_end = src + src_size;

181

182 while (src < src_end && dst < dst_end) {

183 code = *src++;

184 for (i = 0; i < 8 && src < src_end && dst < dst_end; ++i) {

185 if (code & (1 << i)) {

186 *dst++ = *src++;

187 } else {

188 cmd = AV_RL16(src);

189 src += 2;

190 offset = cmd >> 4;

191 if ((int)(dst - dst_start) < offset + 1)

192 return AVERROR_INVALIDDATA;

193 sz = (cmd & 0xF) + 2;

194 /* don't use memcpy/memmove here as the decoding routine

195 * (ab)uses buffer overlappings to repeat bytes in the

196 * destination */

197 sz = FFMIN(sz, dst_end - dst);

198 while (sz--) {

199 *dst = *(dst - offset - 1);

200 ++dst;

201 }

202 }

203 }

204 }

205

206 return 0;

207 }

208

209 static int cin_decode_rle(const unsigned char *src, int src_size,

210 unsigned char *dst, int dst_size)

211 {

212 int len, code;

213 unsigned char *dst_end = dst + dst_size;

214 const unsigned char *src_end = src + src_size;

215

216 while (src + 1 < src_end && dst < dst_end) {

217 code = *src++;

218 if (code & 0x80) {

219 len = code - 0x7F;

220 memset(dst, *src++, FFMIN(len, dst_end - dst));

221 } else {

222 len = code + 1;

223 if (len > src_end-src) {

224 av_log(NULL, AV_LOG_ERROR, "RLE overread\n");

225 return AVERROR_INVALIDDATA;

226 }

227 memcpy(dst, src, FFMIN3(len, dst_end - dst, src_end - src));

228 src += len;

229 }

230 dst += len;

231 }

232 return 0;

233 }

234

235 static int cinvideo_decode_frame(AVCodecContext *avctx,

236 void *data, int *got_frame,

237 AVPacket *avpkt)

238 {

239 const uint8_t *buf = avpkt->data;

240 int buf_size = avpkt->size;

241 CinVideoContext *cin = avctx->priv_data;

242 int i, y, palette_type, palette_colors_count,

243 bitmap_frame_type, bitmap_frame_size, res = 0;

244

245 palette_type = buf[0];

246 palette_colors_count = AV_RL16(buf + 1);

247 bitmap_frame_type = buf[3];

248 buf += 4;

249

250 bitmap_frame_size = buf_size - 4;

251

252 /* handle palette */

253 if (bitmap_frame_size < palette_colors_count * (3 + (palette_type != 0)))

254 return AVERROR_INVALIDDATA;

255 if (palette_type == 0) {

256 if (palette_colors_count > 256)

257 return AVERROR_INVALIDDATA;

258 for (i = 0; i < palette_colors_count; ++i) {

259 cin->palette[i] = 0xFFU << 24 | bytestream_get_le24(&buf);

260 bitmap_frame_size -= 3;

261 }

262 } else {

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

264 cin->palette[buf[0]] = 0xFFU << 24 | AV_RL24(buf + 1);

265 buf += 4;

266 bitmap_frame_size -= 4;

267 }

268 }

269

270 /* note: the decoding routines below assumes that

271 * surface.width = surface.pitch */

272 switch (bitmap_frame_type) {

273 case 9:

274 cin_decode_rle(buf, bitmap_frame_size,

275 cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);

276 break;

277 case 34:

278 cin_decode_rle(buf, bitmap_frame_size,

279 cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);

280 cin_apply_delta_data(cin->bitmap_table[CIN_PRE_BMP],

281 cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);

282 break;

283 case 35:

284 bitmap_frame_size = cin_decode_huffman(buf, bitmap_frame_size,

285 cin->bitmap_table[CIN_INT_BMP], cin->bitmap_size);

286 cin_decode_rle(cin->bitmap_table[CIN_INT_BMP], bitmap_frame_size,

287 cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);

288 break;

289 case 36:

290 bitmap_frame_size = cin_decode_huffman(buf, bitmap_frame_size,

291 cin->bitmap_table[CIN_INT_BMP],

292 cin->bitmap_size);

293 cin_decode_rle(cin->bitmap_table[CIN_INT_BMP], bitmap_frame_size,

294 cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);

295 cin_apply_delta_data(cin->bitmap_table[CIN_PRE_BMP],

296 cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);

297 break;

298 case 37:

299 cin_decode_huffman(buf, bitmap_frame_size,

300 cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);

301 break;

302 case 38:

303 res = cin_decode_lzss(buf, bitmap_frame_size,

304 cin->bitmap_table[CIN_CUR_BMP],

305 cin->bitmap_size);

306 if (res < 0)

307 return res;

308 break;

309 case 39:

310 res = cin_decode_lzss(buf, bitmap_frame_size,

311 cin->bitmap_table[CIN_CUR_BMP],

312 cin->bitmap_size);

313 if (res < 0)

314 return res;

315 cin_apply_delta_data(cin->bitmap_table[CIN_PRE_BMP],

316 cin->bitmap_table[CIN_CUR_BMP], cin->bitmap_size);

317 break;

318 }

319

320 if ((res = ff_reget_buffer(avctx, cin->frame)) < 0)

321 return res;

322

323 memcpy(cin->frame->data[1], cin->palette, sizeof(cin->palette));

324 cin->frame->palette_has_changed = 1;

325 for (y = 0; y < cin->avctx->height; ++y)

326 memcpy(cin->frame->data[0] + (cin->avctx->height - 1 - y) * cin->frame->linesize[0],

327 cin->bitmap_table[CIN_CUR_BMP] + y * cin->avctx->width,

328 cin->avctx->width);

329

330 FFSWAP(uint8_t *, cin->bitmap_table[CIN_CUR_BMP],

331 cin->bitmap_table[CIN_PRE_BMP]);

332

333 if ((res = av_frame_ref(data, cin->frame)) < 0)

334 return res;

335

336 *got_frame = 1;

337

338 return buf_size;

339 }

340

341 static av_cold int cinvideo_decode_end(AVCodecContext *avctx)

342 {

343 CinVideoContext *cin = avctx->priv_data;

344

345 av_frame_free(&cin->frame);

346

347 destroy_buffers(cin);

348

349 return 0;

350 }

351

352 static av_cold int cinaudio_decode_init(AVCodecContext *avctx)

353 {

354 CinAudioContext *cin = avctx->priv_data;

355

356 cin->initial_decode_frame = 1;

357 cin->delta = 0;

358 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

359 avctx->channels = 1;

360 avctx->channel_layout = AV_CH_LAYOUT_MONO;

361

362 return 0;

363 }

364

365 static int cinaudio_decode_frame(AVCodecContext *avctx, void *data,

366 int *got_frame_ptr, AVPacket *avpkt)

367 {

368 AVFrame *frame = data;

369 const uint8_t *buf = avpkt->data;

370 CinAudioContext *cin = avctx->priv_data;

371 const uint8_t *buf_end = buf + avpkt->size;

372 int16_t *samples;

373 int delta, ret;

374

375 /* get output buffer */

376 frame->nb_samples = avpkt->size - cin->initial_decode_frame;

377 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

378 return ret;

379 samples = (int16_t *)frame->data[0];

380

381 delta = cin->delta;

382 if (cin->initial_decode_frame) {

383 cin->initial_decode_frame = 0;

384 delta = sign_extend(AV_RL16(buf), 16);

385 buf += 2;

386 *samples++ = delta;

387 }

388 while (buf < buf_end) {

389 delta += cinaudio_delta16_table[*buf++];

390 delta = av_clip_int16(delta);

391 *samples++ = delta;

392 }

393 cin->delta = delta;

394

395 *got_frame_ptr = 1;

396

397 return avpkt->size;

398 }

399

400 AVCodec ff_dsicinvideo_decoder = {

401 .name = "dsicinvideo",

402 .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"),

403 .type = AVMEDIA_TYPE_VIDEO,

404 .id = AV_CODEC_ID_DSICINVIDEO,

405 .priv_data_size = sizeof(CinVideoContext),

406 .init = cinvideo_decode_init,

407 .close = cinvideo_decode_end,

408 .decode = cinvideo_decode_frame,

409 .capabilities = CODEC_CAP_DR1,

410 };

411

412 AVCodec ff_dsicinaudio_decoder = {

413 .name = "dsicinaudio",

414 .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN audio"),

415 .type = AVMEDIA_TYPE_AUDIO,

416 .id = AV_CODEC_ID_DSICINAUDIO,

417 .priv_data_size = sizeof(CinAudioContext),

418 .init = cinaudio_decode_init,

419 .decode = cinaudio_decode_frame,

420 .capabilities = CODEC_CAP_DR1,

421 };

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