2 * Delphine Software International CIN Audio/Video Decoders
3 * Copyright (c) 2006 Gregory Montoir (cyx@users.sourceforge.net)
5 * This file is part of Libav.
7 * Libav 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.
12 * Libav 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.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * Delphine Software International CIN audio/video decoders
27 #include "libavutil/channel_layout.h"
29 #include "bytestream.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
;
43 unsigned int bitmap_size
;
44 uint32_t palette
[256];
45 uint8_t *bitmap_table
[3];
48 typedef struct CinAudioContext
{
49 int initial_decode_frame
;
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
91 static av_cold
int cinvideo_decode_init(AVCodecContext
*avctx
)
93 CinVideoContext
*cin
= avctx
->priv_data
;
97 avctx
->pix_fmt
= AV_PIX_FMT_PAL8
;
99 cin
->frame
.data
[0] = NULL
;
101 cin
->bitmap_size
= avctx
->width
* avctx
->height
;
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(avctx
, AV_LOG_ERROR
, "Can't allocate bitmap buffers.\n");
111 static void cin_apply_delta_data(const unsigned char *src
, unsigned char *dst
, int size
)
117 static int cin_decode_huffman(const unsigned char *src
, int src_size
, unsigned char *dst
, int dst_size
)
119 int b
, huff_code
= 0;
120 unsigned char huff_code_table
[15];
121 unsigned char *dst_cur
= dst
;
122 unsigned char *dst_end
= dst
+ dst_size
;
123 const unsigned char *src_end
= src
+ src_size
;
125 memcpy(huff_code_table
, src
, 15); src
+= 15;
127 while (src
< src_end
) {
129 if ((huff_code
>> 4) == 15) {
132 *dst_cur
++ = b
| (huff_code
>> 4);
134 *dst_cur
++ = huff_code_table
[huff_code
>> 4];
135 if (dst_cur
>= dst_end
)
139 if (huff_code
== 15) {
142 *dst_cur
++ = huff_code_table
[huff_code
];
143 if (dst_cur
>= dst_end
)
147 return dst_cur
- dst
;
150 static int cin_decode_lzss(const unsigned char *src
, int src_size
, unsigned char *dst
, int dst_size
)
153 int i
, sz
, offset
, code
;
154 unsigned char *dst_end
= dst
+ dst_size
, *dst_start
= dst
;
155 const unsigned char *src_end
= src
+ src_size
;
157 while (src
< src_end
&& dst
< dst_end
) {
159 for (i
= 0; i
< 8 && src
< src_end
&& dst
< dst_end
; ++i
) {
160 if (code
& (1 << i
)) {
163 cmd
= AV_RL16(src
); src
+= 2;
165 if ((int) (dst
- dst_start
) < offset
+ 1)
166 return AVERROR_INVALIDDATA
;
167 sz
= (cmd
& 0xF) + 2;
168 /* don't use memcpy/memmove here as the decoding routine (ab)uses */
169 /* buffer overlappings to repeat bytes in the destination */
170 sz
= FFMIN(sz
, dst_end
- dst
);
172 *dst
= *(dst
- offset
- 1);
182 static void cin_decode_rle(const unsigned char *src
, int src_size
, unsigned char *dst
, int dst_size
)
185 unsigned char *dst_end
= dst
+ dst_size
;
186 const unsigned char *src_end
= src
+ src_size
;
188 while (src
< src_end
&& dst
< dst_end
) {
192 memset(dst
, *src
++, FFMIN(len
, dst_end
- dst
));
195 memcpy(dst
, src
, FFMIN(len
, dst_end
- dst
));
202 static int cinvideo_decode_frame(AVCodecContext
*avctx
,
203 void *data
, int *got_frame
,
206 const uint8_t *buf
= avpkt
->data
;
207 int buf_size
= avpkt
->size
;
208 CinVideoContext
*cin
= avctx
->priv_data
;
209 int i
, y
, palette_type
, palette_colors_count
, bitmap_frame_type
, bitmap_frame_size
, res
= 0;
211 palette_type
= buf
[0];
212 palette_colors_count
= AV_RL16(buf
+1);
213 bitmap_frame_type
= buf
[3];
216 bitmap_frame_size
= buf_size
- 4;
219 if (bitmap_frame_size
< palette_colors_count
* (3 + (palette_type
!= 0)))
220 return AVERROR_INVALIDDATA
;
221 if (palette_type
== 0) {
222 if (palette_colors_count
> 256)
223 return AVERROR_INVALIDDATA
;
224 for (i
= 0; i
< palette_colors_count
; ++i
) {
225 cin
->palette
[i
] = bytestream_get_le24(&buf
);
226 bitmap_frame_size
-= 3;
229 for (i
= 0; i
< palette_colors_count
; ++i
) {
230 cin
->palette
[buf
[0]] = AV_RL24(buf
+1);
232 bitmap_frame_size
-= 4;
236 /* note: the decoding routines below assumes that surface.width = surface.pitch */
237 switch (bitmap_frame_type
) {
239 cin_decode_rle(buf
, bitmap_frame_size
,
240 cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_size
);
243 cin_decode_rle(buf
, bitmap_frame_size
,
244 cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_size
);
245 cin_apply_delta_data(cin
->bitmap_table
[CIN_PRE_BMP
],
246 cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_size
);
249 cin_decode_huffman(buf
, bitmap_frame_size
,
250 cin
->bitmap_table
[CIN_INT_BMP
], cin
->bitmap_size
);
251 cin_decode_rle(cin
->bitmap_table
[CIN_INT_BMP
], bitmap_frame_size
,
252 cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_size
);
255 bitmap_frame_size
= cin_decode_huffman(buf
, bitmap_frame_size
,
256 cin
->bitmap_table
[CIN_INT_BMP
], cin
->bitmap_size
);
257 cin_decode_rle(cin
->bitmap_table
[CIN_INT_BMP
], bitmap_frame_size
,
258 cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_size
);
259 cin_apply_delta_data(cin
->bitmap_table
[CIN_PRE_BMP
],
260 cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_size
);
263 cin_decode_huffman(buf
, bitmap_frame_size
,
264 cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_size
);
267 res
= cin_decode_lzss(buf
, bitmap_frame_size
,
268 cin
->bitmap_table
[CIN_CUR_BMP
],
274 res
= cin_decode_lzss(buf
, bitmap_frame_size
,
275 cin
->bitmap_table
[CIN_CUR_BMP
],
279 cin_apply_delta_data(cin
->bitmap_table
[CIN_PRE_BMP
],
280 cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_size
);
284 if ((res
= ff_reget_buffer(avctx
, &cin
->frame
)) < 0) {
285 av_log(cin
->avctx
, AV_LOG_ERROR
, "delphinecinvideo: reget_buffer() failed to allocate a frame\n");
289 memcpy(cin
->frame
.data
[1], cin
->palette
, sizeof(cin
->palette
));
290 cin
->frame
.palette_has_changed
= 1;
291 for (y
= 0; y
< cin
->avctx
->height
; ++y
)
292 memcpy(cin
->frame
.data
[0] + (cin
->avctx
->height
- 1 - y
) * cin
->frame
.linesize
[0],
293 cin
->bitmap_table
[CIN_CUR_BMP
] + y
* cin
->avctx
->width
,
296 FFSWAP(uint8_t *, cin
->bitmap_table
[CIN_CUR_BMP
], cin
->bitmap_table
[CIN_PRE_BMP
]);
298 if ((res
= av_frame_ref(data
, &cin
->frame
)) < 0)
306 static av_cold
int cinvideo_decode_end(AVCodecContext
*avctx
)
308 CinVideoContext
*cin
= avctx
->priv_data
;
311 av_frame_unref(&cin
->frame
);
313 for (i
= 0; i
< 3; ++i
)
314 av_free(cin
->bitmap_table
[i
]);
319 static av_cold
int cinaudio_decode_init(AVCodecContext
*avctx
)
321 CinAudioContext
*cin
= avctx
->priv_data
;
323 cin
->initial_decode_frame
= 1;
325 avctx
->sample_fmt
= AV_SAMPLE_FMT_S16
;
327 avctx
->channel_layout
= AV_CH_LAYOUT_MONO
;
332 static int cinaudio_decode_frame(AVCodecContext
*avctx
, void *data
,
333 int *got_frame_ptr
, AVPacket
*avpkt
)
335 AVFrame
*frame
= data
;
336 const uint8_t *buf
= avpkt
->data
;
337 CinAudioContext
*cin
= avctx
->priv_data
;
338 const uint8_t *buf_end
= buf
+ avpkt
->size
;
342 /* get output buffer */
343 frame
->nb_samples
= avpkt
->size
- cin
->initial_decode_frame
;
344 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0) {
345 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
348 samples
= (int16_t *)frame
->data
[0];
351 if (cin
->initial_decode_frame
) {
352 cin
->initial_decode_frame
= 0;
353 delta
= sign_extend(AV_RL16(buf
), 16);
357 while (buf
< buf_end
) {
358 delta
+= cinaudio_delta16_table
[*buf
++];
359 delta
= av_clip_int16(delta
);
370 AVCodec ff_dsicinvideo_decoder
= {
371 .name
= "dsicinvideo",
372 .type
= AVMEDIA_TYPE_VIDEO
,
373 .id
= AV_CODEC_ID_DSICINVIDEO
,
374 .priv_data_size
= sizeof(CinVideoContext
),
375 .init
= cinvideo_decode_init
,
376 .close
= cinvideo_decode_end
,
377 .decode
= cinvideo_decode_frame
,
378 .capabilities
= CODEC_CAP_DR1
,
379 .long_name
= NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"),
382 AVCodec ff_dsicinaudio_decoder
= {
383 .name
= "dsicinaudio",
384 .type
= AVMEDIA_TYPE_AUDIO
,
385 .id
= AV_CODEC_ID_DSICINAUDIO
,
386 .priv_data_size
= sizeof(CinAudioContext
),
387 .init
= cinaudio_decode_init
,
388 .decode
= cinaudio_decode_frame
,
389 .capabilities
= CODEC_CAP_DR1
,
390 .long_name
= NULL_IF_CONFIG_SMALL("Delphine Software International CIN audio"),