FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/lcevc_parser.c
Date: 2026-05-03 18:45:46
Exec Total Coverage
Lines: 89 119 74.8%
Functions: 5 5 100.0%
Branches: 35 58 60.3%
Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <stdint.h>
20
21 #include "libavutil/mem.h"
22
23 #include "avcodec.h"
24 #include "bytestream.h"
25 #include "get_bits.h"
26 #include "h2645_parse.h"
27 #include "lcevc.h"
28 #include "lcevc_parse.h"
29 #include "lcevctab.h"
30 #include "parser.h"
31 #include "parser_internal.h"
32
33 #define START_CODE 0x000001 ///< start_code_prefix_one_3bytes
34
35 typedef struct LCEVCParserContext {
36 ParseContext pc;
37
38 H2645Packet pkt;
39
40 int parsed_extradata;
41 int is_lvcc;
42 int nal_length_size;
43 } LCEVCParserContext;
44
45 549 static int lcevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf,
46 int buf_size)
47 {
48 549 LCEVCParserContext *ctx = s->priv_data;
49 549 ParseContext *pc = &ctx->pc;
50
51
2/2
✓ Branch 0 taken 159402 times.
✓ Branch 1 taken 288 times.
 159690 for (int i = 0; i < buf_size; i++) {
52 int nut;
53
54 159402 pc->state = (pc->state << 8) | buf[i];
55
56
2/2
✓ Branch 0 taken 158871 times.
✓ Branch 1 taken 531 times.
 159402 if (((pc->state >> 8) & 0xFFFFFF) != START_CODE)
57 158871 continue;
58
59 531 nut = (pc->state >> 1) & 0x1F;
60
61 // Beginning of access unit
62
3/4
✓ Branch 0 taken 522 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 522 times.
✗ Branch 3 not taken.
 531 if (nut == LCEVC_IDR_NUT || nut == LCEVC_NON_IDR_NUT) {
63
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 261 times.
 531 if (!pc->frame_start_found)
64 270 pc->frame_start_found = 1;
65 else {
66 261 pc->frame_start_found = 0;
67 261 return i - 3;
68 }
69 }
70 }
71
72 288 return END_NOT_FOUND;
73 }
74
75 270 static int parse_nal_unit(AVCodecParserContext *s, AVCodecContext *avctx,
76 const H2645NAL *nal)
77 {
78 GetByteContext gbc;
79 270 bytestream2_init(&gbc, nal->data, nal->size);
80 270 bytestream2_skip(&gbc, 2);
81
82
2/2
✓ Branch 1 taken 576 times.
✓ Branch 2 taken 270 times.
 846 while (bytestream2_get_bytes_left(&gbc) > 1) {
83 GetBitContext gb;
84 uint64_t payload_size;
85 int payload_size_type, payload_type;
86 int block_size;
87
88 576 int ret = init_get_bits8(&gb, gbc.buffer, bytestream2_get_bytes_left(&gbc));
89
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 576 times.
 576 if (ret < 0)
90 ✗ return ret;
91
92 576 payload_size_type = get_bits(&gb, 3);
93 576 payload_type = get_bits(&gb, 5);
94 576 payload_size = payload_size_type;
95
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 576 times.
 576 if (payload_size_type == 6)
96 ✗ return AVERROR_PATCHWELCOME;
97
2/2
✓ Branch 0 taken 288 times.
✓ Branch 1 taken 288 times.
 576 if (payload_size_type == 7)
98 288 payload_size = get_mb(&gb);
99
100
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 576 times.
 576 if (payload_size > INT_MAX - (get_bits_count(&gb) >> 3))
101 ✗ return AVERROR_INVALIDDATA;
102
103 576 block_size = payload_size + (get_bits_count(&gb) >> 3);
104
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 576 times.
 576 if (block_size >= bytestream2_get_bytes_left(&gbc))
105 ✗ return AVERROR_INVALIDDATA;
106
107
3/3
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 558 times.
 576 switch (payload_type) {
108 9 case LCEVC_PAYLOAD_TYPE_SEQUENCE_CONFIG:
109 9 avctx->profile = get_bits(&gb, 4);
110 9 avctx->level = get_bits(&gb, 4);
111 9 break;
112 9 case LCEVC_PAYLOAD_TYPE_GLOBAL_CONFIG: {
113 int resolution_type, chroma_format_idc, bit_depth;
114 int processed_planes_type_flag;
115
116 9 processed_planes_type_flag = get_bits1(&gb);
117 9 resolution_type = get_bits(&gb, 6);
118 9 skip_bits1(&gb);
119 9 chroma_format_idc = get_bits(&gb, 2);
120 9 skip_bits(&gb, 2);
121 9 bit_depth = get_bits(&gb, 2); // enhancement_depth_type
122
123 9 s->format = ff_lcevc_depth_type[bit_depth][chroma_format_idc];
124
125
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 if (resolution_type < 63) {
126 9 s->width = ff_lcevc_resolution_type[resolution_type].width;
127 9 s->height = ff_lcevc_resolution_type[resolution_type].height;
128 } else {
129 int upsample_type, tile_dimensions_type;
130 int temporal_step_width_modifier_signalled_flag, level1_filtering_signalled_flag;
131 // Skip syntax elements until we get to the custom dimension ones
132 ✗ temporal_step_width_modifier_signalled_flag = get_bits1(&gb);
133 ✗ skip_bits(&gb, 3);
134 ✗ upsample_type = get_bits(&gb, 3);
135 ✗ level1_filtering_signalled_flag = get_bits1(&gb);
136 ✗ skip_bits(&gb, 4);
137 ✗ tile_dimensions_type = get_bits(&gb, 2);
138 ✗ skip_bits(&gb, 4);
139 ✗ if (processed_planes_type_flag)
140 ✗ skip_bits(&gb, 4);
141 ✗ if (temporal_step_width_modifier_signalled_flag)
142 ✗ skip_bits(&gb, 8);
143 ✗ if (upsample_type)
144 ✗ skip_bits_long(&gb, 64);
145 ✗ if (level1_filtering_signalled_flag)
146 ✗ skip_bits(&gb, 8);
147 ✗ if (tile_dimensions_type) {
148 ✗ if (tile_dimensions_type == 3)
149 ✗ skip_bits_long(&gb, 32);
150 ✗ skip_bits(&gb, 8);
151 }
152
153 ✗ s->width = get_bits(&gb, 16);
154 ✗ s->height = get_bits(&gb, 16);
155 }
156 9 break;
157 }
158 558 default:
159 558 break;
160 }
161
162 576 bytestream2_skip(&gbc, block_size);
163 }
164
165 270 return 0;
166 }
167
168 279 static int parse_nal_units(AVCodecParserContext *s, const uint8_t *buf,
169 int buf_size, AVCodecContext *avctx)
170 {
171 279 LCEVCParserContext *ctx = s->priv_data;
172
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 279 times.
 279 int flags = (H2645_FLAG_IS_NALFF * !!ctx->is_lvcc) | H2645_FLAG_SMALL_PADDING;
173 int ret, i;
174
175 /* set some sane default values */
176 279 s->pict_type = AV_PICTURE_TYPE_NONE;
177 279 s->key_frame = 0;
178 279 s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
179
180 279 ret = ff_h2645_packet_split(&ctx->pkt, buf, buf_size, avctx,
181 ctx->nal_length_size, AV_CODEC_ID_LCEVC, flags);
182
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 279 times.
 279 if (ret < 0)
183 ✗ return ret;
184
185
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 279 times.
 549 for (i = 0; i < ctx->pkt.nb_nals; i++) {
186 270 H2645NAL *nal = &ctx->pkt.nals[i];
187
188
2/3
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 261 times.
✗ Branch 2 not taken.
 270 switch (nal->type) {
189 9 case LCEVC_IDR_NUT:
190 9 s->key_frame = 1;
191 // fall-through
192 270 case LCEVC_NON_IDR_NUT:
193 270 parse_nal_unit(s, avctx, nal);
194 270 break;
195 ✗ default:
196 ✗ break;
197 }
198 }
199
200 279 return 0;
201 }
202
203 549 static int lcevc_parse(AVCodecParserContext *s,
204 AVCodecContext *avctx,
205 const uint8_t **poutbuf, int *poutbuf_size,
206 const uint8_t *buf, int buf_size)
207 {
208 549 LCEVCParserContext *ctx = s->priv_data;
209 549 ParseContext *pc = &ctx->pc;
210 int next;
211
212
4/4
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 522 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 18 times.
 549 if (!ctx->parsed_extradata && avctx->extradata_size > 4) {
213 9 ctx->parsed_extradata = 1;
214 9 ctx->is_lvcc = !!avctx->extradata[0];
215
216
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (ctx->is_lvcc)
217 ✗ ctx->nal_length_size = (avctx->extradata[4] >> 6) + 1;
218 }
219
220
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 549 times.
 549 if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
221 ✗ next = buf_size;
222 } else {
223 549 next = lcevc_find_frame_end(s, buf, buf_size);
224
2/2
✓ Branch 1 taken 270 times.
✓ Branch 2 taken 279 times.
 549 if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
225 270 *poutbuf = NULL;
226 270 *poutbuf_size = 0;
227 270 return buf_size;
228 }
229 }
230
231 279 parse_nal_units(s, buf, buf_size, avctx);
232
233 279 *poutbuf = buf;
234 279 *poutbuf_size = buf_size;
235 279 return next;
236 }
237
238 9 static void lcevc_parser_close(AVCodecParserContext *s)
239 {
240 9 LCEVCParserContext *ctx = s->priv_data;
241
242 9 ff_h2645_packet_uninit(&ctx->pkt);
243
244 9 av_freep(&ctx->pc.buffer);
245 9 }
246
247 const FFCodecParser ff_lcevc_parser = {
248 PARSER_CODEC_LIST(AV_CODEC_ID_LCEVC),
249 .priv_data_size = sizeof(LCEVCParserContext),
250 .parse = lcevc_parse,
251 .close = lcevc_parser_close,
252 };
253