FFmpeg coverage


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