FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/8bps.c
Date: 2024-02-16 17:37:06
Exec Total Coverage
Lines: 54 78 69.2%
Functions: 2 2 100.0%
Branches: 19 30 63.3%

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 * : GBRP (RGB 24bpp)
30 * : GBRAP (RGB 32bpp, 4th plane is alpha)
31 */
32
33 #include <string.h>
34
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/internal.h"
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "decode.h"
40
41 typedef struct EightBpsContext {
42 AVCodecContext *avctx;
43
44 uint8_t planes;
45 uint8_t planemap[4];
46
47 uint32_t pal[256];
48 } EightBpsContext;
49
50 13 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
51 int *got_frame, AVPacket *avpkt)
52 {
53 13 const uint8_t *buf = avpkt->data;
54 13 int buf_size = avpkt->size;
55 13 EightBpsContext * const c = avctx->priv_data;
56 13 const uint8_t *encoded = buf;
57 uint8_t *pixptr, *pixptr_end;
58 13 unsigned int height = avctx->height; // Real image height
59 unsigned int dlen, p, row;
60 const uint8_t *lp, *dp, *ep;
61 uint8_t count;
62 13 const uint8_t *planemap = c->planemap;
63 13 unsigned int planes = c->planes;
64 int ret;
65
66
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (buf_size < planes * height * 2)
67 return AVERROR_INVALIDDATA;
68
69
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
13 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
70 return ret;
71
72 13 ep = encoded + buf_size;
73
74 /* Set data pointer after line lengths */
75 13 dp = encoded + planes * (height << 1);
76
77
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 12 times.
25 for (p = 0; p < planes; p++) {
78 13 const int pi = planemap[p];
79 /* Lines length pointer for this plane */
80 13 lp = encoded + p * (height << 1);
81
82 /* Decode a plane */
83
2/2
✓ Branch 0 taken 3039 times.
✓ Branch 1 taken 12 times.
3051 for (row = 0; row < height; row++) {
84 3039 pixptr = frame->data[pi] + row * frame->linesize[pi];
85 3039 pixptr_end = pixptr + frame->linesize[pi];
86
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3039 times.
3039 if (ep - lp < row * 2 + 2)
87 return AVERROR_INVALIDDATA;
88 3039 dlen = AV_RB16(lp + row * 2);
89 /* Decode a row of this plane */
90
2/2
✓ Branch 0 taken 76107 times.
✓ Branch 1 taken 3038 times.
79145 while (dlen > 0) {
91
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76107 times.
76107 if (ep - dp <= 1)
92 return AVERROR_INVALIDDATA;
93
2/2
✓ Branch 0 taken 37173 times.
✓ Branch 1 taken 38934 times.
76107 if ((count = *dp++) <= 127) {
94 37173 count++;
95 37173 dlen -= count + 1;
96
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37173 times.
37173 if (pixptr_end - pixptr < count)
97 break;
98
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 37172 times.
37173 if (ep - dp < count)
99 1 return AVERROR_INVALIDDATA;
100 37172 memcpy(pixptr, dp, count);
101 37172 pixptr += count;
102 37172 dp += count;
103 } else {
104 38934 count = 257 - count;
105
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38934 times.
38934 if (pixptr_end - pixptr < count)
106 break;
107 38934 memset(pixptr, dp[0], count);
108 38934 pixptr += count;
109 38934 dp++;
110 38934 dlen -= 2;
111 }
112 }
113 }
114 }
115
116
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
12 if (avctx->bits_per_coded_sample <= 8) {
117 #if FF_API_PALETTE_HAS_CHANGED
118 FF_DISABLE_DEPRECATION_WARNINGS
119 12 frame->palette_has_changed =
120 #endif
121 12 ff_copy_palette(c->pal, avpkt, avctx);
122 #if FF_API_PALETTE_HAS_CHANGED
123 FF_ENABLE_DEPRECATION_WARNINGS
124 #endif
125
126 12 memcpy(frame->data[1], c->pal, AVPALETTE_SIZE);
127 }
128
129 12 *got_frame = 1;
130
131 /* always report that the buffer was completely consumed */
132 12 return buf_size;
133 }
134
135 2 static av_cold int decode_init(AVCodecContext *avctx)
136 {
137 2 EightBpsContext * const c = avctx->priv_data;
138
139 2 c->avctx = avctx;
140
141
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) {
142 2 case 8:
143 2 avctx->pix_fmt = AV_PIX_FMT_PAL8;
144 2 c->planes = 1;
145 2 c->planemap[0] = 0; // 1st plane is palette indexes
146 2 break;
147 case 24:
148 avctx->pix_fmt = AV_PIX_FMT_GBRP;
149 c->planes = 3;
150 c->planemap[0] = 2; // 1st plane is red
151 c->planemap[1] = 0; // 2nd plane is green
152 c->planemap[2] = 1; // 3rd plane is blue
153 break;
154 case 32:
155 avctx->pix_fmt = AV_PIX_FMT_GBRAP;
156 c->planes = 4;
157 break;
158 default:
159 av_log(avctx, AV_LOG_ERROR, "Error: Unsupported color depth: %u.\n",
160 avctx->bits_per_coded_sample);
161 return AVERROR_INVALIDDATA;
162 }
163
164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
165 c->planemap[0] = 2; // 1st plane is red
166 c->planemap[1] = 0; // 2nd plane is green
167 c->planemap[2] = 1; // 3rd plane is blue
168 c->planemap[3] = 3; // 4th plane is alpha
169 }
170 2 return 0;
171 }
172
173 const FFCodec ff_eightbps_decoder = {
174 .p.name = "8bps",
175 CODEC_LONG_NAME("QuickTime 8BPS video"),
176 .p.type = AVMEDIA_TYPE_VIDEO,
177 .p.id = AV_CODEC_ID_8BPS,
178 .priv_data_size = sizeof(EightBpsContext),
179 .init = decode_init,
180 FF_CODEC_DECODE_CB(decode_frame),
181 .p.capabilities = AV_CODEC_CAP_DR1,
182 };
183