FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/rtjpeg.c
Date: 2026-01-23 14:02:51
Exec Total Coverage
Lines: 66 70 94.3%
Functions: 4 4 100.0%
Branches: 46 56 82.1%
Line Branch Exec Source
1 /*
2 * RTJpeg decoding functions
3 * Copyright (c) 2006 Reimar Doeffinger
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 #include "libavutil/attributes.h"
23 #include "libavutil/common.h"
24 #include "get_bits.h"
25 #include "rtjpeg.h"
26
27 #define PUT_COEFF(c) \
28 i = scan[coeff--]; \
29 block[i] = (c) * quant[i];
30
31 /// aligns the bitstream to the given power of two
32 #define ALIGN(a) \
33 n = (-get_bits_count(gb)) & (a - 1); \
34 if (n) {skip_bits(gb, n);}
35
36 /**
37 * @brief read one block from stream
38 * @param gb contains stream data
39 * @param block where data is written to
40 * @param scan array containing the mapping stream address -> block position
41 * @param quant quantization factors
42 * @return 0 means the block is not coded, < 0 means an error occurred.
43 *
44 * Note: GetBitContext is used to make the code simpler, since all data is
45 * aligned this could be done faster in a different way, e.g. as it is done
46 * in MPlayer libmpcodecs/native/rtjpegn.c.
47 */
48 223200 static inline int get_block(GetBitContext *gb, int16_t *block, const uint8_t *scan,
49 const uint32_t *quant) {
50 int coeff, i, n;
51 int8_t ac;
52 223200 uint8_t dc = get_bits(gb, 8);
53
54 // block not coded
55
2/2
✓ Branch 0 taken 102402 times.
✓ Branch 1 taken 120798 times.
 223200 if (dc == 255)
56 102402 return 0;
57
58 // number of non-zero coefficients
59 120798 coeff = get_bits(gb, 6);
60
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 120798 times.
 120798 if (get_bits_left(gb) < (coeff << 1))
61 ✗ return AVERROR_INVALIDDATA;
62
63 // normally we would only need to clear the (63 - coeff) last values,
64 // but since we do not know where they are we just clear the whole block
65 120798 memset(block, 0, 64 * sizeof(int16_t));
66
67 // 2 bits per coefficient
68
2/2
✓ Branch 0 taken 691920 times.
✓ Branch 1 taken 63484 times.
 755404 while (coeff) {
69 691920 ac = get_sbits(gb, 2);
70
2/2
✓ Branch 0 taken 57314 times.
✓ Branch 1 taken 634606 times.
 691920 if (ac == -2)
71 57314 break; // continue with more bits
72 634606 PUT_COEFF(ac);
73 }
74
75 // 4 bits per coefficient
76
2/2
✓ Branch 1 taken 78684 times.
✓ Branch 2 taken 42114 times.
 120798 ALIGN(4);
77
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 120798 times.
 120798 if (get_bits_left(gb) < (coeff << 2))
78 ✗ return AVERROR_INVALIDDATA;
79
2/2
✓ Branch 0 taken 451590 times.
✓ Branch 1 taken 93872 times.
 545462 while (coeff) {
80 451590 ac = get_sbits(gb, 4);
81
2/2
✓ Branch 0 taken 26926 times.
✓ Branch 1 taken 424664 times.
 451590 if (ac == -8)
82 26926 break; // continue with more bits
83 424664 PUT_COEFF(ac);
84 }
85
86 // 8 bits per coefficient
87
2/2
✓ Branch 1 taken 41741 times.
✓ Branch 2 taken 79057 times.
 120798 ALIGN(8);
88
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 120798 times.
 120798 if (get_bits_left(gb) < (coeff << 3))
89 ✗ return AVERROR_INVALIDDATA;
90
2/2
✓ Branch 0 taken 153559 times.
✓ Branch 1 taken 120798 times.
 274357 while (coeff) {
91 153559 ac = get_sbits(gb, 8);
92 153559 PUT_COEFF(ac);
93 }
94
95 120798 PUT_COEFF(dc);
96 120798 return 1;
97 }
98
99 /**
100 * @brief decode one rtjpeg YUV420 frame
101 * @param c context, must be initialized via ff_rtjpeg_decode_init
102 * @param f AVFrame to place decoded frame into. If parts of the frame
103 * are not coded they are left unchanged, so consider initializing it
104 * @param buf buffer containing input data
105 * @param buf_size length of input data in bytes
106 * @return number of bytes consumed from the input buffer
107 */
108 57 int ff_rtjpeg_decode_frame_yuv420(RTJpegContext *c, AVFrame *f,
109 const uint8_t *buf, int buf_size) {
110 GetBitContext gb;
111 57 int w = c->w / 16, h = c->h / 16;
112 int x, y, ret;
113 57 uint8_t *y1 = f->data[0], *y2 = f->data[0] + 8 * f->linesize[0];
114 57 uint8_t *u = f->data[1], *v = f->data[2];
115
116
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 57 times.
 57 if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
117 ✗ return ret;
118
119
2/2
✓ Branch 0 taken 1110 times.
✓ Branch 1 taken 57 times.
 1167 for (y = 0; y < h; y++) {
120
2/2
✓ Branch 0 taken 37200 times.
✓ Branch 1 taken 1110 times.
 38310 for (x = 0; x < w; x++) {
121 #define BLOCK(quant, dst, stride) do { \
122 int res = get_block(&gb, block, c->scan, quant); \
123 if (res < 0) \
124 return res; \
125 if (res > 0) \
126 c->idsp.idct_put(dst, stride, block); \
127 } while (0)
128 37200 int16_t *block = c->block;
129
3/4
✗ Branch 1 not taken.
✓ Branch 2 taken 37200 times.
✓ Branch 3 taken 20211 times.
✓ Branch 4 taken 16989 times.
 37200 BLOCK(c->lquant, y1, f->linesize[0]);
130 37200 y1 += 8;
131
3/4
✗ Branch 1 not taken.
✓ Branch 2 taken 37200 times.
✓ Branch 3 taken 20263 times.
✓ Branch 4 taken 16937 times.
 37200 BLOCK(c->lquant, y1, f->linesize[0]);
132 37200 y1 += 8;
133
3/4
✗ Branch 1 not taken.
✓ Branch 2 taken 37200 times.
✓ Branch 3 taken 20242 times.
✓ Branch 4 taken 16958 times.
 37200 BLOCK(c->lquant, y2, f->linesize[0]);
134 37200 y2 += 8;
135
3/4
✗ Branch 1 not taken.
✓ Branch 2 taken 37200 times.
✓ Branch 3 taken 20267 times.
✓ Branch 4 taken 16933 times.
 37200 BLOCK(c->lquant, y2, f->linesize[0]);
136 37200 y2 += 8;
137
3/4
✗ Branch 1 not taken.
✓ Branch 2 taken 37200 times.
✓ Branch 3 taken 19521 times.
✓ Branch 4 taken 17679 times.
 37200 BLOCK(c->cquant, u, f->linesize[1]);
138 37200 u += 8;
139
3/4
✗ Branch 1 not taken.
✓ Branch 2 taken 37200 times.
✓ Branch 3 taken 20294 times.
✓ Branch 4 taken 16906 times.
 37200 BLOCK(c->cquant, v, f->linesize[2]);
140 37200 v += 8;
141 }
142 1110 y1 += 2 * 8 * (f->linesize[0] - w);
143 1110 y2 += 2 * 8 * (f->linesize[0] - w);
144 1110 u += 8 * (f->linesize[1] - w);
145 1110 v += 8 * (f->linesize[2] - w);
146 }
147 57 return get_bits_count(&gb) / 8;
148 }
149
150 /**
151 * @brief initialize an RTJpegContext, may be called multiple times
152 * @param c context to initialize
153 * @param width width of image, will be rounded down to the nearest multiple
154 * of 16 for decoding
155 * @param height height of image, will be rounded down to the nearest multiple
156 * of 16 for decoding
157 * @param lquant luma quantization table to use
158 * @param cquant chroma quantization table to use
159 */
160 54 void ff_rtjpeg_decode_init(RTJpegContext *c, int width, int height,
161 const uint32_t *lquant, const uint32_t *cquant) {
162 int i;
163
2/2
✓ Branch 0 taken 3456 times.
✓ Branch 1 taken 54 times.
 3510 for (i = 0; i < 64; i++) {
164 3456 int p = c->idsp.idct_permutation[i];
165 3456 c->lquant[p] = lquant[i];
166 3456 c->cquant[p] = cquant[i];
167 }
168 54 c->w = width;
169 54 c->h = height;
170 54 }
171
172 4 av_cold void ff_rtjpeg_init(RTJpegContext *c, struct AVCodecContext *avctx)
173 {
174 int i;
175
176 4 ff_idctdsp_init(&c->idsp, avctx);
177
178
2/2
✓ Branch 0 taken 256 times.
✓ Branch 1 taken 4 times.
 260 for (i = 0; i < 64; i++) {
179 256 int z = ff_zigzag_direct[i];
180 256 z = ((z << 3) | (z >> 3)) & 63; // rtjpeg uses a transposed variant
181
182 // permute the scan and quantization tables for the chosen idct
183 256 c->scan[i] = c->idsp.idct_permutation[z];
184 }
185 4 }
186