Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Quicktime Planar RGB (8BPS) Video Decoder | ||
3 | * Copyright (C) 2003 Roberto Togni | ||
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 | */ | ||
21 | |||
22 | /** | ||
23 | * @file | ||
24 | * QT 8BPS Video Decoder by Roberto Togni | ||
25 | * For more information about the 8BPS format, visit: | ||
26 | * http://www.pcisys.net/~melanson/codecs/ | ||
27 | * | ||
28 | * Supports: PAL8 (RGB 8bpp, paletted) | ||
29 | * : BGR24 (RGB 24bpp) (can also output it as RGB32) | ||
30 | * : RGB32 (RGB 32bpp, 4th plane is alpha) | ||
31 | */ | ||
32 | |||
33 | #include <string.h> | ||
34 | |||
35 | #include "libavutil/bswap.h" | ||
36 | #include "libavutil/internal.h" | ||
37 | #include "avcodec.h" | ||
38 | #include "codec_internal.h" | ||
39 | #include "decode.h" | ||
40 | |||
41 | |||
42 | static const enum AVPixelFormat pixfmt_rgb24[] = { | ||
43 | AV_PIX_FMT_BGR24, AV_PIX_FMT_0RGB32, AV_PIX_FMT_NONE }; | ||
44 | |||
45 | typedef struct EightBpsContext { | ||
46 | AVCodecContext *avctx; | ||
47 | |||
48 | unsigned char planes; | ||
49 | unsigned char planemap[4]; | ||
50 | |||
51 | uint32_t pal[256]; | ||
52 | } EightBpsContext; | ||
53 | |||
54 | 13 | static int decode_frame(AVCodecContext *avctx, AVFrame *frame, | |
55 | int *got_frame, AVPacket *avpkt) | ||
56 | { | ||
57 | 13 | const uint8_t *buf = avpkt->data; | |
58 | 13 | int buf_size = avpkt->size; | |
59 | 13 | EightBpsContext * const c = avctx->priv_data; | |
60 | 13 | const unsigned char *encoded = buf; | |
61 | unsigned char *pixptr, *pixptr_end; | ||
62 | 13 | unsigned int height = avctx->height; // Real image height | |
63 | unsigned int dlen, p, row; | ||
64 | const unsigned char *lp, *dp, *ep; | ||
65 | unsigned char count; | ||
66 | unsigned int px_inc; | ||
67 | 13 | unsigned int planes = c->planes; | |
68 | 13 | unsigned char *planemap = c->planemap; | |
69 | int ret; | ||
70 | |||
71 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | if (buf_size < planes * height * 2) |
72 | ✗ | return AVERROR_INVALIDDATA; | |
73 | |||
74 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
|
13 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
75 | ✗ | return ret; | |
76 | |||
77 | 13 | ep = encoded + buf_size; | |
78 | |||
79 | /* Set data pointer after line lengths */ | ||
80 | 13 | dp = encoded + planes * (height << 1); | |
81 | |||
82 | 13 | px_inc = planes + (avctx->pix_fmt == AV_PIX_FMT_0RGB32); | |
83 | |||
84 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 12 times.
|
25 | for (p = 0; p < planes; p++) { |
85 | /* Lines length pointer for this plane */ | ||
86 | 13 | lp = encoded + p * (height << 1); | |
87 | |||
88 | /* Decode a plane */ | ||
89 |
2/2✓ Branch 0 taken 3039 times.
✓ Branch 1 taken 12 times.
|
3051 | for (row = 0; row < height; row++) { |
90 | 3039 | pixptr = frame->data[0] + row * frame->linesize[0] + planemap[p]; | |
91 | 3039 | pixptr_end = pixptr + frame->linesize[0]; | |
92 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3039 times.
|
3039 | if (ep - lp < row * 2 + 2) |
93 | ✗ | return AVERROR_INVALIDDATA; | |
94 | 3039 | dlen = av_be2ne16(*(const unsigned short *)(lp + row * 2)); | |
95 | /* Decode a row of this plane */ | ||
96 |
2/2✓ Branch 0 taken 76107 times.
✓ Branch 1 taken 3038 times.
|
79145 | while (dlen > 0) { |
97 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 76107 times.
|
76107 | if (ep - dp <= 1) |
98 | ✗ | return AVERROR_INVALIDDATA; | |
99 |
2/2✓ Branch 0 taken 37173 times.
✓ Branch 1 taken 38934 times.
|
76107 | if ((count = *dp++) <= 127) { |
100 | 37173 | count++; | |
101 | 37173 | dlen -= count + 1; | |
102 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 37173 times.
|
37173 | if (pixptr_end - pixptr < count * px_inc) |
103 | ✗ | break; | |
104 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 37172 times.
|
37173 | if (ep - dp < count) |
105 | 1 | return AVERROR_INVALIDDATA; | |
106 |
2/2✓ Branch 0 taken 897539 times.
✓ Branch 1 taken 37172 times.
|
934711 | while (count--) { |
107 | 897539 | *pixptr = *dp++; | |
108 | 897539 | pixptr += px_inc; | |
109 | } | ||
110 | } else { | ||
111 | 38934 | count = 257 - count; | |
112 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38934 times.
|
38934 | if (pixptr_end - pixptr < count * px_inc) |
113 | ✗ | break; | |
114 |
2/2✓ Branch 0 taken 196346 times.
✓ Branch 1 taken 38934 times.
|
235280 | while (count--) { |
115 | 196346 | *pixptr = *dp; | |
116 | 196346 | pixptr += px_inc; | |
117 | } | ||
118 | 38934 | dp++; | |
119 | 38934 | dlen -= 2; | |
120 | } | ||
121 | } | ||
122 | } | ||
123 | } | ||
124 | |||
125 |
1/2✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
|
12 | if (avctx->bits_per_coded_sample <= 8) { |
126 | 12 | frame->palette_has_changed = ff_copy_palette(c->pal, avpkt, avctx); | |
127 | |||
128 | 12 | memcpy (frame->data[1], c->pal, AVPALETTE_SIZE); | |
129 | } | ||
130 | |||
131 | 12 | *got_frame = 1; | |
132 | |||
133 | /* always report that the buffer was completely consumed */ | ||
134 | 12 | return buf_size; | |
135 | } | ||
136 | |||
137 | 2 | static av_cold int decode_init(AVCodecContext *avctx) | |
138 | { | ||
139 | 2 | EightBpsContext * const c = avctx->priv_data; | |
140 | |||
141 | 2 | c->avctx = avctx; | |
142 | |||
143 |
1/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
2 | switch (avctx->bits_per_coded_sample) { |
144 | 2 | case 8: | |
145 | 2 | avctx->pix_fmt = AV_PIX_FMT_PAL8; | |
146 | 2 | c->planes = 1; | |
147 | 2 | c->planemap[0] = 0; // 1st plane is palette indexes | |
148 | 2 | break; | |
149 | ✗ | case 24: | |
150 | ✗ | avctx->pix_fmt = ff_get_format(avctx, pixfmt_rgb24); | |
151 | ✗ | c->planes = 3; | |
152 | ✗ | c->planemap[0] = 2; // 1st plane is red | |
153 | ✗ | c->planemap[1] = 1; // 2nd plane is green | |
154 | ✗ | c->planemap[2] = 0; // 3rd plane is blue | |
155 | ✗ | break; | |
156 | ✗ | case 32: | |
157 | ✗ | avctx->pix_fmt = AV_PIX_FMT_RGB32; | |
158 | ✗ | c->planes = 4; | |
159 | /* handle planemap setup later for decoding rgb24 data as rbg32 */ | ||
160 | ✗ | break; | |
161 | ✗ | default: | |
162 | ✗ | av_log(avctx, AV_LOG_ERROR, "Error: Unsupported color depth: %u.\n", | |
163 | avctx->bits_per_coded_sample); | ||
164 | ✗ | return AVERROR_INVALIDDATA; | |
165 | } | ||
166 | |||
167 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (avctx->pix_fmt == AV_PIX_FMT_RGB32) { |
168 | ✗ | c->planemap[0] = HAVE_BIGENDIAN ? 1 : 2; // 1st plane is red | |
169 | ✗ | c->planemap[1] = HAVE_BIGENDIAN ? 2 : 1; // 2nd plane is green | |
170 | ✗ | c->planemap[2] = HAVE_BIGENDIAN ? 3 : 0; // 3rd plane is blue | |
171 | ✗ | c->planemap[3] = HAVE_BIGENDIAN ? 0 : 3; // 4th plane is alpha | |
172 | } | ||
173 | 2 | return 0; | |
174 | } | ||
175 | |||
176 | const FFCodec ff_eightbps_decoder = { | ||
177 | .p.name = "8bps", | ||
178 | CODEC_LONG_NAME("QuickTime 8BPS video"), | ||
179 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
180 | .p.id = AV_CODEC_ID_8BPS, | ||
181 | .priv_data_size = sizeof(EightBpsContext), | ||
182 | .init = decode_init, | ||
183 | FF_CODEC_DECODE_CB(decode_frame), | ||
184 | .p.capabilities = AV_CODEC_CAP_DR1, | ||
185 | }; | ||
186 |