1 |
|
|
/* |
2 |
|
|
* Canopus Lossless Codec decoder |
3 |
|
|
* |
4 |
|
|
* Copyright (c) 2012-2013 Derek Buitenhuis |
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 |
|
|
*/ |
22 |
|
|
|
23 |
|
|
#include <inttypes.h> |
24 |
|
|
|
25 |
|
|
#include "libavutil/intreadwrite.h" |
26 |
|
|
#include "bswapdsp.h" |
27 |
|
|
#include "canopus.h" |
28 |
|
|
#include "get_bits.h" |
29 |
|
|
#include "avcodec.h" |
30 |
|
|
#include "internal.h" |
31 |
|
|
#include "thread.h" |
32 |
|
|
|
33 |
|
|
#define VLC_BITS 7 |
34 |
|
|
#define VLC_DEPTH 2 |
35 |
|
|
|
36 |
|
|
|
37 |
|
|
typedef struct CLLCContext { |
38 |
|
|
AVCodecContext *avctx; |
39 |
|
|
BswapDSPContext bdsp; |
40 |
|
|
|
41 |
|
|
uint8_t *swapped_buf; |
42 |
|
|
int swapped_buf_size; |
43 |
|
|
} CLLCContext; |
44 |
|
|
|
45 |
|
106 |
static int read_code_table(CLLCContext *ctx, GetBitContext *gb, VLC *vlc) |
46 |
|
|
{ |
47 |
|
|
uint8_t symbols[256]; |
48 |
|
|
uint8_t bits[256]; |
49 |
|
|
int num_lens, num_codes, num_codes_sum; |
50 |
|
|
int i, j, count; |
51 |
|
|
|
52 |
|
106 |
count = 0; |
53 |
|
106 |
num_codes_sum = 0; |
54 |
|
|
|
55 |
|
106 |
num_lens = get_bits(gb, 5); |
56 |
|
|
|
57 |
✗✓ |
106 |
if (num_lens > VLC_BITS * VLC_DEPTH) { |
58 |
|
|
av_log(ctx->avctx, AV_LOG_ERROR, "To long VLCs %d\n", num_lens); |
59 |
|
|
return AVERROR_INVALIDDATA; |
60 |
|
|
} |
61 |
|
|
|
62 |
✓✓ |
1545 |
for (i = 0; i < num_lens; i++) { |
63 |
|
1439 |
num_codes = get_bits(gb, 9); |
64 |
|
1439 |
num_codes_sum += num_codes; |
65 |
|
|
|
66 |
✗✓ |
1439 |
if (num_codes_sum > 256) { |
67 |
|
|
av_log(ctx->avctx, AV_LOG_ERROR, |
68 |
|
|
"Too many VLCs (%d) to be read.\n", num_codes_sum); |
69 |
|
|
return AVERROR_INVALIDDATA; |
70 |
|
|
} |
71 |
|
|
|
72 |
✓✓ |
27476 |
for (j = 0; j < num_codes; j++) { |
73 |
|
26037 |
symbols[count] = get_bits(gb, 8); |
74 |
|
26037 |
bits[count] = i + 1; |
75 |
|
|
|
76 |
|
26037 |
count++; |
77 |
|
|
} |
78 |
|
|
} |
79 |
|
|
|
80 |
|
106 |
return ff_init_vlc_from_lengths(vlc, VLC_BITS, count, bits, 1, |
81 |
|
106 |
symbols, 1, 1, 0, 0, ctx->avctx); |
82 |
|
|
} |
83 |
|
|
|
84 |
|
|
/* |
85 |
|
|
* Unlike the RGB24 read/restore, which reads in a component at a time, |
86 |
|
|
* ARGB read/restore reads in ARGB quads. |
87 |
|
|
*/ |
88 |
|
4320 |
static int read_argb_line(CLLCContext *ctx, GetBitContext *gb, int *top_left, |
89 |
|
|
VLC *vlc, uint8_t *outbuf) |
90 |
|
|
{ |
91 |
|
|
uint8_t *dst; |
92 |
|
|
int pred[4]; |
93 |
|
|
int code; |
94 |
|
|
int i; |
95 |
|
|
|
96 |
|
4320 |
OPEN_READER(bits, gb); |
97 |
|
|
|
98 |
|
4320 |
dst = outbuf; |
99 |
|
4320 |
pred[0] = top_left[0]; |
100 |
|
4320 |
pred[1] = top_left[1]; |
101 |
|
4320 |
pred[2] = top_left[2]; |
102 |
|
4320 |
pred[3] = top_left[3]; |
103 |
|
|
|
104 |
✓✓ |
5533920 |
for (i = 0; i < ctx->avctx->width; i++) { |
105 |
|
|
/* Always get the alpha component */ |
106 |
|
5529600 |
UPDATE_CACHE(bits, gb); |
107 |
✓✓ |
5529600 |
GET_VLC(code, bits, gb, vlc[0].table, VLC_BITS, VLC_DEPTH); |
108 |
|
|
|
109 |
|
5529600 |
pred[0] += code; |
110 |
|
5529600 |
dst[0] = pred[0]; |
111 |
|
|
|
112 |
|
|
/* Skip the components if they are entirely transparent */ |
113 |
✓✓ |
5529600 |
if (dst[0]) { |
114 |
|
|
/* Red */ |
115 |
|
872412 |
UPDATE_CACHE(bits, gb); |
116 |
✓✓ |
872412 |
GET_VLC(code, bits, gb, vlc[1].table, VLC_BITS, VLC_DEPTH); |
117 |
|
|
|
118 |
|
872412 |
pred[1] += code; |
119 |
|
872412 |
dst[1] = pred[1]; |
120 |
|
|
|
121 |
|
|
/* Green */ |
122 |
|
872412 |
UPDATE_CACHE(bits, gb); |
123 |
✓✓ |
872412 |
GET_VLC(code, bits, gb, vlc[2].table, VLC_BITS, VLC_DEPTH); |
124 |
|
|
|
125 |
|
872412 |
pred[2] += code; |
126 |
|
872412 |
dst[2] = pred[2]; |
127 |
|
|
|
128 |
|
|
/* Blue */ |
129 |
|
872412 |
UPDATE_CACHE(bits, gb); |
130 |
✓✓ |
872412 |
GET_VLC(code, bits, gb, vlc[3].table, VLC_BITS, VLC_DEPTH); |
131 |
|
|
|
132 |
|
872412 |
pred[3] += code; |
133 |
|
872412 |
dst[3] = pred[3]; |
134 |
|
|
} else { |
135 |
|
4657188 |
dst[1] = 0; |
136 |
|
4657188 |
dst[2] = 0; |
137 |
|
4657188 |
dst[3] = 0; |
138 |
|
|
} |
139 |
|
|
|
140 |
|
5529600 |
dst += 4; |
141 |
|
|
} |
142 |
|
|
|
143 |
|
4320 |
CLOSE_READER(bits, gb); |
144 |
|
|
|
145 |
|
4320 |
top_left[0] = outbuf[0]; |
146 |
|
|
|
147 |
|
|
/* Only stash components if they are not transparent */ |
148 |
✗✓ |
4320 |
if (top_left[0]) { |
149 |
|
|
top_left[1] = outbuf[1]; |
150 |
|
|
top_left[2] = outbuf[2]; |
151 |
|
|
top_left[3] = outbuf[3]; |
152 |
|
|
} |
153 |
|
|
|
154 |
|
4320 |
return 0; |
155 |
|
|
} |
156 |
|
|
|
157 |
|
23040 |
static int read_rgb24_component_line(CLLCContext *ctx, GetBitContext *gb, |
158 |
|
|
int *top_left, VLC *vlc, uint8_t *outbuf) |
159 |
|
|
{ |
160 |
|
|
uint8_t *dst; |
161 |
|
|
int pred, code; |
162 |
|
|
int i; |
163 |
|
|
|
164 |
|
23040 |
OPEN_READER(bits, gb); |
165 |
|
|
|
166 |
|
23040 |
dst = outbuf; |
167 |
|
23040 |
pred = *top_left; |
168 |
|
|
|
169 |
|
|
/* Simultaneously read and restore the line */ |
170 |
✓✓ |
14768640 |
for (i = 0; i < ctx->avctx->width; i++) { |
171 |
|
14745600 |
UPDATE_CACHE(bits, gb); |
172 |
✓✓ |
14745600 |
GET_VLC(code, bits, gb, vlc->table, VLC_BITS, VLC_DEPTH); |
173 |
|
|
|
174 |
|
14745600 |
pred += code; |
175 |
|
14745600 |
dst[0] = pred; |
176 |
|
14745600 |
dst += 3; |
177 |
|
|
} |
178 |
|
|
|
179 |
|
23040 |
CLOSE_READER(bits, gb); |
180 |
|
|
|
181 |
|
|
/* Stash the first pixel */ |
182 |
|
23040 |
*top_left = outbuf[0]; |
183 |
|
|
|
184 |
|
23040 |
return 0; |
185 |
|
|
} |
186 |
|
|
|
187 |
|
24480 |
static int read_yuv_component_line(CLLCContext *ctx, GetBitContext *gb, |
188 |
|
|
int *top_left, VLC *vlc, uint8_t *outbuf, |
189 |
|
|
int is_chroma) |
190 |
|
|
{ |
191 |
|
|
int pred, code; |
192 |
|
|
int i; |
193 |
|
|
|
194 |
|
24480 |
OPEN_READER(bits, gb); |
195 |
|
|
|
196 |
|
24480 |
pred = *top_left; |
197 |
|
|
|
198 |
|
|
/* Simultaneously read and restore the line */ |
199 |
✓✓ |
10469280 |
for (i = 0; i < ctx->avctx->width >> is_chroma; i++) { |
200 |
|
10444800 |
UPDATE_CACHE(bits, gb); |
201 |
✓✓ |
10444800 |
GET_VLC(code, bits, gb, vlc->table, VLC_BITS, VLC_DEPTH); |
202 |
|
|
|
203 |
|
10444800 |
pred += code; |
204 |
|
10444800 |
outbuf[i] = pred; |
205 |
|
|
} |
206 |
|
|
|
207 |
|
24480 |
CLOSE_READER(bits, gb); |
208 |
|
|
|
209 |
|
|
/* Stash the first pixel */ |
210 |
|
24480 |
*top_left = outbuf[0]; |
211 |
|
|
|
212 |
|
24480 |
return 0; |
213 |
|
|
} |
214 |
|
|
|
215 |
|
6 |
static int decode_argb_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic) |
216 |
|
|
{ |
217 |
|
6 |
AVCodecContext *avctx = ctx->avctx; |
218 |
|
|
uint8_t *dst; |
219 |
|
|
int pred[4]; |
220 |
|
|
int ret; |
221 |
|
|
int i, j; |
222 |
|
|
VLC vlc[4]; |
223 |
|
|
|
224 |
|
6 |
pred[0] = 0; |
225 |
|
6 |
pred[1] = 0x80; |
226 |
|
6 |
pred[2] = 0x80; |
227 |
|
6 |
pred[3] = 0x80; |
228 |
|
|
|
229 |
|
6 |
dst = pic->data[0]; |
230 |
|
|
|
231 |
|
6 |
skip_bits(gb, 16); |
232 |
|
|
|
233 |
|
|
/* Read in code table for each plane */ |
234 |
✓✓ |
30 |
for (i = 0; i < 4; i++) { |
235 |
|
24 |
ret = read_code_table(ctx, gb, &vlc[i]); |
236 |
✗✓ |
24 |
if (ret < 0) { |
237 |
|
|
for (j = 0; j < i; j++) |
238 |
|
|
ff_free_vlc(&vlc[j]); |
239 |
|
|
|
240 |
|
|
av_log(ctx->avctx, AV_LOG_ERROR, |
241 |
|
|
"Could not read code table %d.\n", i); |
242 |
|
|
return ret; |
243 |
|
|
} |
244 |
|
|
} |
245 |
|
|
|
246 |
|
|
/* Read in and restore every line */ |
247 |
✓✓ |
4326 |
for (i = 0; i < avctx->height; i++) { |
248 |
|
4320 |
read_argb_line(ctx, gb, pred, vlc, dst); |
249 |
|
|
|
250 |
|
4320 |
dst += pic->linesize[0]; |
251 |
|
|
} |
252 |
|
|
|
253 |
✓✓ |
30 |
for (i = 0; i < 4; i++) |
254 |
|
24 |
ff_free_vlc(&vlc[i]); |
255 |
|
|
|
256 |
|
6 |
return 0; |
257 |
|
|
} |
258 |
|
|
|
259 |
|
16 |
static int decode_rgb24_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic) |
260 |
|
|
{ |
261 |
|
16 |
AVCodecContext *avctx = ctx->avctx; |
262 |
|
|
uint8_t *dst; |
263 |
|
|
int pred[3]; |
264 |
|
|
int ret; |
265 |
|
|
int i, j; |
266 |
|
|
VLC vlc[3]; |
267 |
|
|
|
268 |
|
16 |
pred[0] = 0x80; |
269 |
|
16 |
pred[1] = 0x80; |
270 |
|
16 |
pred[2] = 0x80; |
271 |
|
|
|
272 |
|
16 |
dst = pic->data[0]; |
273 |
|
|
|
274 |
|
16 |
skip_bits(gb, 16); |
275 |
|
|
|
276 |
|
|
/* Read in code table for each plane */ |
277 |
✓✓ |
64 |
for (i = 0; i < 3; i++) { |
278 |
|
48 |
ret = read_code_table(ctx, gb, &vlc[i]); |
279 |
✗✓ |
48 |
if (ret < 0) { |
280 |
|
|
for (j = 0; j < i; j++) |
281 |
|
|
ff_free_vlc(&vlc[j]); |
282 |
|
|
|
283 |
|
|
av_log(ctx->avctx, AV_LOG_ERROR, |
284 |
|
|
"Could not read code table %d.\n", i); |
285 |
|
|
return ret; |
286 |
|
|
} |
287 |
|
|
} |
288 |
|
|
|
289 |
|
|
/* Read in and restore every line */ |
290 |
✓✓ |
7696 |
for (i = 0; i < avctx->height; i++) { |
291 |
✓✓ |
30720 |
for (j = 0; j < 3; j++) |
292 |
|
23040 |
read_rgb24_component_line(ctx, gb, &pred[j], &vlc[j], &dst[j]); |
293 |
|
|
|
294 |
|
7680 |
dst += pic->linesize[0]; |
295 |
|
|
} |
296 |
|
|
|
297 |
✓✓ |
64 |
for (i = 0; i < 3; i++) |
298 |
|
48 |
ff_free_vlc(&vlc[i]); |
299 |
|
|
|
300 |
|
16 |
return 0; |
301 |
|
|
} |
302 |
|
|
|
303 |
|
17 |
static int decode_yuv_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic) |
304 |
|
|
{ |
305 |
|
17 |
AVCodecContext *avctx = ctx->avctx; |
306 |
|
|
uint8_t block; |
307 |
|
|
uint8_t *dst[3]; |
308 |
|
|
int pred[3]; |
309 |
|
|
int ret; |
310 |
|
|
int i, j; |
311 |
|
|
VLC vlc[2]; |
312 |
|
|
|
313 |
|
17 |
pred[0] = 0x80; |
314 |
|
17 |
pred[1] = 0x80; |
315 |
|
17 |
pred[2] = 0x80; |
316 |
|
|
|
317 |
|
17 |
dst[0] = pic->data[0]; |
318 |
|
17 |
dst[1] = pic->data[1]; |
319 |
|
17 |
dst[2] = pic->data[2]; |
320 |
|
|
|
321 |
|
17 |
skip_bits(gb, 8); |
322 |
|
|
|
323 |
|
17 |
block = get_bits(gb, 8); |
324 |
✗✓ |
17 |
if (block) { |
325 |
|
|
avpriv_request_sample(ctx->avctx, "Blocked YUV"); |
326 |
|
|
return AVERROR_PATCHWELCOME; |
327 |
|
|
} |
328 |
|
|
|
329 |
|
|
/* Read in code table for luma and chroma */ |
330 |
✓✓ |
51 |
for (i = 0; i < 2; i++) { |
331 |
|
34 |
ret = read_code_table(ctx, gb, &vlc[i]); |
332 |
✗✓ |
34 |
if (ret < 0) { |
333 |
|
|
for (j = 0; j < i; j++) |
334 |
|
|
ff_free_vlc(&vlc[j]); |
335 |
|
|
|
336 |
|
|
av_log(ctx->avctx, AV_LOG_ERROR, |
337 |
|
|
"Could not read code table %d.\n", i); |
338 |
|
|
return ret; |
339 |
|
|
} |
340 |
|
|
} |
341 |
|
|
|
342 |
|
|
/* Read in and restore every line */ |
343 |
✓✓ |
8177 |
for (i = 0; i < avctx->height; i++) { |
344 |
|
8160 |
read_yuv_component_line(ctx, gb, &pred[0], &vlc[0], dst[0], 0); /* Y */ |
345 |
|
8160 |
read_yuv_component_line(ctx, gb, &pred[1], &vlc[1], dst[1], 1); /* U */ |
346 |
|
8160 |
read_yuv_component_line(ctx, gb, &pred[2], &vlc[1], dst[2], 1); /* V */ |
347 |
|
|
|
348 |
✓✓ |
32640 |
for (j = 0; j < 3; j++) |
349 |
|
24480 |
dst[j] += pic->linesize[j]; |
350 |
|
|
} |
351 |
|
|
|
352 |
✓✓ |
51 |
for (i = 0; i < 2; i++) |
353 |
|
34 |
ff_free_vlc(&vlc[i]); |
354 |
|
|
|
355 |
|
17 |
return 0; |
356 |
|
|
} |
357 |
|
|
|
358 |
|
39 |
static int cllc_decode_frame(AVCodecContext *avctx, void *data, |
359 |
|
|
int *got_picture_ptr, AVPacket *avpkt) |
360 |
|
|
{ |
361 |
|
39 |
CLLCContext *ctx = avctx->priv_data; |
362 |
|
39 |
AVFrame *pic = data; |
363 |
|
39 |
ThreadFrame frame = { .f = data }; |
364 |
|
39 |
uint8_t *src = avpkt->data; |
365 |
|
|
uint32_t info_tag, info_offset; |
366 |
|
|
int data_size; |
367 |
|
|
GetBitContext gb; |
368 |
|
|
int coding_type, ret; |
369 |
|
|
|
370 |
✗✓ |
39 |
if (avpkt->size < 4 + 4) { |
371 |
|
|
av_log(avctx, AV_LOG_ERROR, "Frame is too small %d.\n", avpkt->size); |
372 |
|
|
return AVERROR_INVALIDDATA; |
373 |
|
|
} |
374 |
|
|
|
375 |
|
39 |
info_offset = 0; |
376 |
|
39 |
info_tag = AV_RL32(src); |
377 |
✓✗ |
39 |
if (info_tag == MKTAG('I', 'N', 'F', 'O')) { |
378 |
|
39 |
info_offset = AV_RL32(src + 4); |
379 |
✓✗✗✓
|
39 |
if (info_offset > UINT32_MAX - 8 || info_offset + 8 > avpkt->size) { |
380 |
|
|
av_log(avctx, AV_LOG_ERROR, |
381 |
|
|
"Invalid INFO header offset: 0x%08"PRIX32" is too large.\n", |
382 |
|
|
info_offset); |
383 |
|
|
return AVERROR_INVALIDDATA; |
384 |
|
|
} |
385 |
|
39 |
ff_canopus_parse_info_tag(avctx, src + 8, info_offset); |
386 |
|
|
|
387 |
|
39 |
info_offset += 8; |
388 |
|
39 |
src += info_offset; |
389 |
|
|
} |
390 |
|
|
|
391 |
|
39 |
data_size = (avpkt->size - info_offset) & ~1; |
392 |
|
|
|
393 |
|
|
/* Make sure our bswap16'd buffer is big enough */ |
394 |
|
39 |
av_fast_padded_malloc(&ctx->swapped_buf, |
395 |
|
39 |
&ctx->swapped_buf_size, data_size); |
396 |
✗✓ |
39 |
if (!ctx->swapped_buf) { |
397 |
|
|
av_log(avctx, AV_LOG_ERROR, "Could not allocate swapped buffer.\n"); |
398 |
|
|
return AVERROR(ENOMEM); |
399 |
|
|
} |
400 |
|
|
|
401 |
|
|
/* bswap16 the buffer since CLLC's bitreader works in 16-bit words */ |
402 |
|
39 |
ctx->bdsp.bswap16_buf((uint16_t *) ctx->swapped_buf, (uint16_t *) src, |
403 |
|
|
data_size / 2); |
404 |
|
|
|
405 |
✗✓ |
39 |
if ((ret = init_get_bits8(&gb, ctx->swapped_buf, data_size)) < 0) |
406 |
|
|
return ret; |
407 |
|
|
|
408 |
|
|
/* |
409 |
|
|
* Read in coding type. The types are as follows: |
410 |
|
|
* |
411 |
|
|
* 0 - YUY2 |
412 |
|
|
* 1 - BGR24 (Triples) |
413 |
|
|
* 2 - BGR24 (Quads) |
414 |
|
|
* 3 - BGRA |
415 |
|
|
*/ |
416 |
|
39 |
coding_type = (AV_RL32(src) >> 8) & 0xFF; |
417 |
|
39 |
av_log(avctx, AV_LOG_DEBUG, "Frame coding type: %d\n", coding_type); |
418 |
|
|
|
419 |
✗✓ |
39 |
if(get_bits_left(&gb) < avctx->height * avctx->width) |
420 |
|
|
return AVERROR_INVALIDDATA; |
421 |
|
|
|
422 |
✓✓✓✗
|
39 |
switch (coding_type) { |
423 |
|
17 |
case 0: |
424 |
|
17 |
avctx->pix_fmt = AV_PIX_FMT_YUV422P; |
425 |
|
17 |
avctx->bits_per_raw_sample = 8; |
426 |
|
|
|
427 |
✗✓ |
17 |
if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) |
428 |
|
|
return ret; |
429 |
|
|
|
430 |
|
17 |
ret = decode_yuv_frame(ctx, &gb, pic); |
431 |
✗✓ |
17 |
if (ret < 0) |
432 |
|
|
return ret; |
433 |
|
|
|
434 |
|
17 |
break; |
435 |
|
16 |
case 1: |
436 |
|
|
case 2: |
437 |
|
16 |
avctx->pix_fmt = AV_PIX_FMT_RGB24; |
438 |
|
16 |
avctx->bits_per_raw_sample = 8; |
439 |
|
|
|
440 |
✗✓ |
16 |
if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) |
441 |
|
|
return ret; |
442 |
|
|
|
443 |
|
16 |
ret = decode_rgb24_frame(ctx, &gb, pic); |
444 |
✗✓ |
16 |
if (ret < 0) |
445 |
|
|
return ret; |
446 |
|
|
|
447 |
|
16 |
break; |
448 |
|
6 |
case 3: |
449 |
|
6 |
avctx->pix_fmt = AV_PIX_FMT_ARGB; |
450 |
|
6 |
avctx->bits_per_raw_sample = 8; |
451 |
|
|
|
452 |
✗✓ |
6 |
if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) |
453 |
|
|
return ret; |
454 |
|
|
|
455 |
|
6 |
ret = decode_argb_frame(ctx, &gb, pic); |
456 |
✗✓ |
6 |
if (ret < 0) |
457 |
|
|
return ret; |
458 |
|
|
|
459 |
|
6 |
break; |
460 |
|
|
default: |
461 |
|
|
av_log(avctx, AV_LOG_ERROR, "Unknown coding type: %d.\n", coding_type); |
462 |
|
|
return AVERROR_INVALIDDATA; |
463 |
|
|
} |
464 |
|
|
|
465 |
|
39 |
pic->key_frame = 1; |
466 |
|
39 |
pic->pict_type = AV_PICTURE_TYPE_I; |
467 |
|
|
|
468 |
|
39 |
*got_picture_ptr = 1; |
469 |
|
|
|
470 |
|
39 |
return avpkt->size; |
471 |
|
|
} |
472 |
|
|
|
473 |
|
6 |
static av_cold int cllc_decode_close(AVCodecContext *avctx) |
474 |
|
|
{ |
475 |
|
6 |
CLLCContext *ctx = avctx->priv_data; |
476 |
|
|
|
477 |
|
6 |
av_freep(&ctx->swapped_buf); |
478 |
|
|
|
479 |
|
6 |
return 0; |
480 |
|
|
} |
481 |
|
|
|
482 |
|
6 |
static av_cold int cllc_decode_init(AVCodecContext *avctx) |
483 |
|
|
{ |
484 |
|
6 |
CLLCContext *ctx = avctx->priv_data; |
485 |
|
|
|
486 |
|
|
/* Initialize various context values */ |
487 |
|
6 |
ctx->avctx = avctx; |
488 |
|
6 |
ctx->swapped_buf = NULL; |
489 |
|
6 |
ctx->swapped_buf_size = 0; |
490 |
|
|
|
491 |
|
6 |
ff_bswapdsp_init(&ctx->bdsp); |
492 |
|
|
|
493 |
|
6 |
return 0; |
494 |
|
|
} |
495 |
|
|
|
496 |
|
|
AVCodec ff_cllc_decoder = { |
497 |
|
|
.name = "cllc", |
498 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("Canopus Lossless Codec"), |
499 |
|
|
.type = AVMEDIA_TYPE_VIDEO, |
500 |
|
|
.id = AV_CODEC_ID_CLLC, |
501 |
|
|
.priv_data_size = sizeof(CLLCContext), |
502 |
|
|
.init = cllc_decode_init, |
503 |
|
|
.decode = cllc_decode_frame, |
504 |
|
|
.close = cllc_decode_close, |
505 |
|
|
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, |
506 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, |
507 |
|
|
}; |