FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/cbs_sei_syntax_template.c
Date: 2026-01-23 19:11:46
Exec Total Coverage
Lines: 139 249 55.8%
Functions: 20 50 40.0%
Branches: 64 251 25.5%
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 ✗ SEI_FUNC(filler_payload, (CodedBitstreamContext *ctx, RWContext *rw,
20 SEIRawFillerPayload *current,
21 SEIMessageState *state))
22 {
23 int err, i;
24
25 ✗ HEADER("Filler Payload");
26
27 #ifdef READ
28 ✗ current->payload_size = state->payload_size;
29 #endif
30
31 ✗ for (i = 0; i < current->payload_size; i++)
32 ✗ fixed(8, ff_byte, 0xff);
33
34 ✗ return 0;
35 }
36
37 300 SEI_FUNC(user_data_registered, (CodedBitstreamContext *ctx, RWContext *rw,
38 SEIRawUserDataRegistered *current,
39 SEIMessageState *state))
40 {
41 int err, i, j;
42
43 150 HEADER("User Data Registered ITU-T T.35");
44
45
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
 150 u(8, itu_t_t35_country_code, 0x00, 0xff);
46
1/2
✓ Branch 0 taken 75 times.
✗ Branch 1 not taken.
 150 if (current->itu_t_t35_country_code != 0xff)
47 150 i = 1;
48 else {
49 ✗ u(8, itu_t_t35_country_code_extension_byte, 0x00, 0xff);
50 ✗ i = 2;
51 }
52
53 #ifdef READ
54
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
 50 if (state->payload_size < i) {
55 ✗ av_log(ctx->log_ctx, AV_LOG_ERROR,
56 "Invalid SEI user data registered payload.\n");
57 ✗ return AVERROR_INVALIDDATA;
58 }
59 50 current->data_length = state->payload_size - i;
60
61
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 25 times.
 50 allocate(current->data_ref, state->payload_size);
62 50 current->data = current->data_ref;
63
64 50 *current->data++ = current->itu_t_t35_country_code;
65
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 25 times.
 50 if (current->itu_t_t35_country_code == 0xff)
66 ✗ *current->data++ = current->itu_t_t35_country_code_extension_byte;
67 #else
68
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 100 allocate(current->data, current->data_length);
69 #endif
70
2/2
✓ Branch 0 taken 729 times.
✓ Branch 1 taken 75 times.
 1608 for (j = 0; j < current->data_length; j++)
71
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 729 times.
 1458 xu(8, itu_t_t35_payload_byte[], current->data[j], 0x00, 0xff, 1, i + j);
72
73 150 return 0;
74 }
75
76 264 SEI_FUNC(user_data_unregistered, (CodedBitstreamContext *ctx, RWContext *rw,
77 SEIRawUserDataUnregistered *current,
78 SEIMessageState *state))
79 {
80 int err, i;
81
82 132 HEADER("User Data Unregistered");
83
84 #ifdef READ
85
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
 44 if (state->payload_size < 16) {
86 ✗ av_log(ctx->log_ctx, AV_LOG_ERROR,
87 "Invalid SEI user data unregistered payload.\n");
88 ✗ return AVERROR_INVALIDDATA;
89 }
90 44 current->data_length = state->payload_size - 16;
91 #endif
92
93
2/2
✓ Branch 0 taken 1056 times.
✓ Branch 1 taken 66 times.
 2244 for (i = 0; i < 16; i++)
94
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1056 times.
 2112 us(8, uuid_iso_iec_11578[i], 0x00, 0xff, 1, i);
95
96 #ifdef READ
97
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
 44 allocate(current->data_ref, state->payload_size);
98 44 memcpy(current->data_ref, current->uuid_iso_iec_11578, sizeof(current->uuid_iso_iec_11578));
99 44 current->data = current->data_ref + 16;
100 #else
101
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44 times.
 88 allocate(current->data, current->data_length);
102 #endif
103
104
2/2
✓ Branch 0 taken 18363 times.
✓ Branch 1 taken 66 times.
 36858 for (i = 0; i < current->data_length; i++)
105
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 18363 times.
 36726 xu(8, user_data_payload_byte[i], current->data[i], 0x00, 0xff, 1, i);
106
107 132 return 0;
108 }
109
110 ✗ SEI_FUNC(frame_packing_arrangement, (CodedBitstreamContext *ctx, RWContext *rw,
111 SEIRawFramePackingArrangement *current,
112 SEIMessageState *unused))
113 {
114 int err;
115
116 ✗ HEADER("Frame Packing Arrangement");
117
118 ✗ ue(fp_arrangement_id, 0, MAX_UINT_BITS(31));
119 ✗ flag(fp_arrangement_cancel_flag);
120 ✗ if (!current->fp_arrangement_cancel_flag) {
121 ✗ u(7, fp_arrangement_type, 3, 5);
122 ✗ flag(fp_quincunx_sampling_flag);
123 ✗ u(6, fp_content_interpretation_type, 0, 2);
124 ✗ flag(fp_spatial_flipping_flag);
125 ✗ flag(fp_frame0_flipped_flag);
126 ✗ flag(fp_field_views_flag);
127 ✗ flag(fp_current_frame_is_frame0_flag);
128 ✗ flag(fp_frame0_self_contained_flag);
129 ✗ flag(fp_frame1_self_contained_flag);
130 ✗ if (!current->fp_quincunx_sampling_flag && current->fp_arrangement_type != 5) {
131 ✗ ub(4, fp_frame0_grid_position_x);
132 ✗ ub(4, fp_frame0_grid_position_y);
133 ✗ ub(4, fp_frame1_grid_position_x);
134 ✗ ub(4, fp_frame1_grid_position_y);
135 }
136 ✗ fixed(8, fp_arrangement_reserved_byte, 0);
137 ✗ flag(fp_arrangement_persistence_flag);
138 }
139 ✗ flag(fp_upsampled_aspect_ratio_flag);
140
141 ✗ return 0;
142 }
143
144 29568 SEI_FUNC(decoded_picture_hash, (CodedBitstreamContext *ctx,
145 RWContext *rw,
146 SEIRawDecodedPictureHash *current,
147 SEIMessageState *unused))
148 {
149 int err, c_idx, i;
150
151 14784 HEADER("Decoded Picture Hash");
152
153
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7392 times.
 14784 u(8, dph_sei_hash_type, 0, 2);
154
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7392 times.
 14784 flag(dph_sei_single_component_flag);
155
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7392 times.
 14784 ub(7, dph_sei_reserved_zero_7bits);
156
157
4/4
✓ Branch 0 taken 516 times.
✓ Branch 1 taken 28536 times.
✓ Branch 2 taken 21660 times.
✓ Branch 3 taken 7392 times.
 58104 for (c_idx = 0; c_idx < (current->dph_sei_single_component_flag ? 1 : 3);
158 43320 c_idx++) {
159
1/2
✓ Branch 0 taken 21660 times.
✗ Branch 1 not taken.
 43320 if (current->dph_sei_hash_type == 0) {
160
2/2
✓ Branch 0 taken 346560 times.
✓ Branch 1 taken 21660 times.
 736440 for (i = 0; i < 16; i++)
161
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 346560 times.
 693120 us(8, dph_sei_picture_md5[c_idx][i], 0x00, 0xff, 2, c_idx, i);
162 ✗ } else if (current->dph_sei_hash_type == 1) {
163 ✗ us(16, dph_sei_picture_crc[c_idx], 0x0000, 0xffff, 1, c_idx);
164 ✗ } else if (current->dph_sei_hash_type == 2) {
165 ✗ us(32, dph_sei_picture_checksum[c_idx], 0x00000000, 0xffffffff, 1,
166 c_idx);
167 }
168 }
169 14784 return 0;
170 }
171
172 12 SEI_FUNC(mastering_display_colour_volume,
173 (CodedBitstreamContext *ctx, RWContext *rw,
174 SEIRawMasteringDisplayColourVolume *current,
175 SEIMessageState *state))
176 {
177 int err, c;
178
179 6 HEADER("Mastering Display Colour Volume");
180
181
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 3 times.
 24 for (c = 0; c < 3; c++) {
182
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
 18 ubs(16, display_primaries_x[c], 1, c);
183
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
 18 ubs(16, display_primaries_y[c], 1, c);
184 }
185
186
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 6 ub(16, white_point_x);
187
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 6 ub(16, white_point_y);
188
189
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 6 ub(32, max_display_mastering_luminance);
190
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 6 ub(32, min_display_mastering_luminance);
191
192 6 return 0;
193 }
194
195 ✗ SEI_FUNC(content_light_level_info, (CodedBitstreamContext *ctx, RWContext *rw,
196 SEIRawContentLightLevelInfo *current,
197 SEIMessageState *state))
198 {
199 int err;
200
201 ✗ HEADER("Content Light Level Information");
202
203 ✗ ub(16, max_content_light_level);
204 ✗ ub(16, max_pic_average_light_level);
205
206 ✗ return 0;
207 }
208
209 ✗ SEI_FUNC(alternative_transfer_characteristics,
210 (CodedBitstreamContext *ctx, RWContext *rw,
211 SEIRawAlternativeTransferCharacteristics *current,
212 SEIMessageState *state))
213 {
214 int err;
215
216 ✗ HEADER("Alternative Transfer Characteristics");
217
218 ✗ ub(8, preferred_transfer_characteristics);
219
220 ✗ return 0;
221 }
222
223 ✗ SEI_FUNC(ambient_viewing_environment,
224 (CodedBitstreamContext *ctx, RWContext *rw,
225 SEIRawAmbientViewingEnvironment *current,
226 SEIMessageState *state))
227 {
228 static const uint16_t max_ambient_light_value = 50000;
229 int err;
230
231 ✗ HEADER("Ambient Viewing Environment");
232
233 ✗ u(32, ambient_illuminance, 1, MAX_UINT_BITS(32));
234 ✗ u(16, ambient_light_x, 0, max_ambient_light_value);
235 ✗ u(16, ambient_light_y, 0, max_ambient_light_value);
236
237 ✗ return 0;
238 }
239
240 ✗ SEI_FUNC(film_grain_characteristics,
241 (CodedBitstreamContext *ctx, RWContext *rw,
242 SEIRawFilmGrainCharacteristics *current,
243 SEIMessageState *state))
244 {
245 int err, c, i, j;
246
247 ✗ HEADER("Film Grain Characteristics");
248
249 ✗ flag(fg_characteristics_cancel_flag);
250 ✗ if (!current->fg_characteristics_cancel_flag) {
251 int filmGrainBitDepth[3];
252
253 ✗ u(2, fg_model_id, 0, 1);
254 ✗ flag(fg_separate_colour_description_present_flag);
255 ✗ if (current->fg_separate_colour_description_present_flag) {
256 ✗ ub(3, fg_bit_depth_luma_minus8);
257 ✗ ub(3, fg_bit_depth_chroma_minus8);
258 ✗ flag(fg_full_range_flag);
259 ✗ ub(8, fg_colour_primaries);
260 ✗ ub(8, fg_transfer_characteristics);
261 ✗ ub(8, fg_matrix_coeffs);
262 }
263
264 ✗ filmGrainBitDepth[0] = current->fg_bit_depth_luma_minus8 + 8;
265 ✗ filmGrainBitDepth[1] =
266 ✗ filmGrainBitDepth[2] = current->fg_bit_depth_chroma_minus8 + 8;
267
268 ✗ u(2, fg_blending_mode_id, 0, 1);
269 ✗ ub(4, fg_log2_scale_factor);
270 ✗ for (c = 0; c < 3; c++)
271 ✗ flags(fg_comp_model_present_flag[c], 1, c);
272
273 ✗ for (c = 0; c < 3; c++) {
274 ✗ if (current->fg_comp_model_present_flag[c]) {
275 ✗ ubs(8, fg_num_intensity_intervals_minus1[c], 1, c);
276 ✗ us(3, fg_num_model_values_minus1[c], 0, 5, 1, c);
277 ✗ for (i = 0; i <= current->fg_num_intensity_intervals_minus1[c]; i++) {
278 ✗ ubs(8, fg_intensity_interval_lower_bound[c][i], 2, c, i);
279 ✗ ubs(8, fg_intensity_interval_upper_bound[c][i], 2, c, i);
280 ✗ for (j = 0; j <= current->fg_num_model_values_minus1[c]; j++)
281 ✗ ses(fg_comp_model_value[c][i][j], 0 - current->fg_model_id * (1 << (filmGrainBitDepth[c] - 1)),
282 ((1 << filmGrainBitDepth[c]) - 1) - current->fg_model_id * (1 << (filmGrainBitDepth[c] - 1)),
283 3, c, i, j);
284 }
285 }
286 }
287 ✗ flag(fg_characteristics_persistence_flag);
288 }
289
290 ✗ return 0;
291 }
292
293 ✗ SEI_FUNC(display_orientation, (CodedBitstreamContext *ctx, RWContext *rw,
294 SEIRawDisplayOrientation *current,
295 SEIMessageState *state))
296 {
297 int err;
298
299 ✗ HEADER("Display Orientation");
300
301 ✗ flag(display_orientation_cancel_flag);
302 ✗ if (!current->display_orientation_cancel_flag) {
303 ✗ flag(display_orientation_persistence_flag);
304 ✗ u(3, display_orientation_transform_type, 0, 7);
305 ✗ ub(3, display_orientation_reserved_zero_3bits);
306 }
307
308 ✗ return 0;
309 }
310
311 88 SEI_FUNC(frame_field_information, (CodedBitstreamContext *ctx, RWContext *rw,
312 SEIRawFrameFieldInformation *current,
313 SEIMessageState *state))
314 {
315 int err;
316
317 44 HEADER("Frame-field information");
318
319
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
 44 flag(ffi_field_pic_flag);
320
1/2
✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
 44 if (current->ffi_field_pic_flag) {
321
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
 44 flag(ffi_bottom_field_flag);
322
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
 44 flag(ffi_pairing_indicated_flag);
323
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
 44 if (current->ffi_pairing_indicated_flag)
324 ✗ flag(ffi_paired_with_next_field_flag);
325 } else {
326 ✗ flag(ffi_display_fields_from_frame_flag);
327 ✗ if (current->ffi_display_fields_from_frame_flag)
328 ✗ flag(ffi_top_field_first_flag);
329 ✗ u(8, ffi_display_elemental_periods_minus1, 0, 0xff);
330 }
331
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
 44 u(2, ffi_source_scan_type, 0, 3);
332
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
 44 flag(ffi_duplicate_flag);
333
334 44 return 0;
335 }
336
337 29276 static int FUNC(message)(CodedBitstreamContext *ctx, RWContext *rw,
338 SEIRawMessage *current)
339 {
340 const SEIMessageTypeDescriptor *desc;
341 int err, i;
342
343 29276 desc = ff_cbs_sei_find_type(ctx, current->payload_type);
344
2/2
✓ Branch 0 taken 14369 times.
✓ Branch 1 taken 269 times.
 29276 if (desc) {
345 28738 SEIMessageState state = {
346 28738 .payload_type = current->payload_type,
347 28738 .payload_size = current->payload_size,
348 28738 .extension_present = current->extension_bit_length > 0,
349 };
350 int start_position, current_position, bits_written;
351
352 #ifdef READ
353
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5945 times.
 11890 CHECK(ff_cbs_sei_alloc_message_payload(current, desc));
354 #endif
355
356 28738 start_position = bit_position(rw);
357
358
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 14369 times.
 28738 CHECK(desc->READWRITE(ctx, rw, current->payload, &state));
359
360 28738 current_position = bit_position(rw);
361 28738 bits_written = current_position - start_position;
362
363
3/4
✓ Branch 1 taken 12064 times.
✓ Branch 2 taken 2305 times.
✓ Branch 3 taken 12064 times.
✗ Branch 4 not taken.
 28738 if (byte_alignment(rw) || state.extension_present ||
364
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12064 times.
 24128 bits_written < 8 * current->payload_size) {
365 size_t bits_left;
366
367 #ifdef READ
368 2110 GetBitContext tmp = *rw;
369 int trailing_bits, trailing_zero_bits;
370
371 2110 bits_left = 8 * current->payload_size - bits_written;
372
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1055 times.
 2110 if (bits_left > 8)
373 ✗ skip_bits_long(&tmp, bits_left - 8);
374 2110 trailing_bits = get_bits(&tmp, FFMIN(bits_left, 8));
375
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1055 times.
 2110 if (trailing_bits == 0) {
376 // The trailing bits must contain a bit_equal_to_one, so
377 // they can't all be zero.
378 ✗ return AVERROR_INVALIDDATA;
379 }
380 2110 trailing_zero_bits = ff_ctz(trailing_bits);
381 2110 current->extension_bit_length =
382 2110 bits_left - 1 - trailing_zero_bits;
383 #endif
384
385
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2305 times.
 4610 if (current->extension_bit_length > 0) {
386 ✗ allocate(current->extension_data,
387 (current->extension_bit_length + 7) / 8);
388
389 ✗ bits_left = current->extension_bit_length;
390 ✗ for (i = 0; bits_left > 0; i++) {
391 ✗ int length = FFMIN(bits_left, 8);
392 ✗ xu(length, reserved_payload_extension_data,
393 current->extension_data[i],
394 0, MAX_UINT_BITS(length), 0);
395 ✗ bits_left -= length;
396 }
397 }
398
399
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2305 times.
 4610 fixed(1, bit_equal_to_one, 1);
400
2/2
✓ Branch 1 taken 3124 times.
✓ Branch 2 taken 2305 times.
 10858 while (byte_alignment(rw))
401
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3124 times.
 6248 fixed(1, bit_equal_to_zero, 0);
402 }
403
404 #ifdef WRITE
405 16848 current->payload_size = (put_bits_count(rw) - start_position) / 8;
406 #endif
407 } else {
408 uint8_t *data;
409
410 #ifdef READ
411
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 135 times.
 270 allocate(current->payload_ref, current->payload_size);
412 270 current->payload = current->payload_ref;
413 #else
414
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 134 times.
 268 allocate(current->payload, current->payload_size);
415 #endif
416 538 data = current->payload;
417
418
2/2
✓ Branch 0 taken 6370 times.
✓ Branch 1 taken 269 times.
 13278 for (i = 0; i < current->payload_size; i++)
419
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6370 times.
 12740 xu(8, payload_byte[i], data[i], 0, 255, 1, i);
420 }
421
422 29276 return 0;
423 }
424
425 10319 static int FUNC(message_list)(CodedBitstreamContext *ctx, RWContext *rw,
426 SEIRawMessageList *current, int prefix)
427 {
428 SEIRawMessage *message;
429 int err, k;
430
431 #ifdef READ
432 6080 for (k = 0;; k++) {
433 6080 uint32_t payload_type = 0;
434 6080 uint32_t payload_size = 0;
435 uint32_t tmp;
436 GetBitContext payload_gbc;
437
438 6100 while (show_bits(rw, 8) == 0xff) {
439 20 fixed(8, ff_byte, 0xff);
440 20 payload_type += 255;
441 }
442 6080 xu(8, last_payload_type_byte, tmp, 0, 254, 0);
443 6080 payload_type += tmp;
444
445 6103 while (show_bits(rw, 8) == 0xff) {
446 23 fixed(8, ff_byte, 0xff);
447 23 payload_size += 255;
448 }
449 6080 xu(8, last_payload_size_byte, tmp, 0, 254, 0);
450 6080 payload_size += tmp;
451
452 // There must be space remaining for both the payload and
453 // the trailing bits on the SEI NAL unit.
454 6080 if (payload_size + 1 > get_bits_left(rw) / 8) {
455 ✗ av_log(ctx->log_ctx, AV_LOG_ERROR,
456 "Invalid SEI message: payload_size too large "
457 "(%"PRIu32" bytes).\n", payload_size);
458 ✗ return AVERROR_INVALIDDATA;
459 }
460 6080 CHECK(init_get_bits(&payload_gbc, rw->buffer,
461 get_bits_count(rw) + 8 * payload_size));
462 6080 skip_bits_long(&payload_gbc, get_bits_count(rw));
463
464 6080 CHECK(ff_cbs_sei_list_add(current));
465 6080 message = &current->messages[k];
466
467 6080 message->payload_type = payload_type;
468 6080 message->payload_size = payload_size;
469
470 6080 CHECK(FUNC(message)(ctx, &payload_gbc, message));
471
472 6080 skip_bits_long(rw, 8 * payload_size);
473
474 6080 if (!cbs_h2645_read_more_rbsp_data(rw))
475 6060 break;
476 }
477 #else
478 8538 for (k = 0; k < current->nb_messages; k++) {
479 PutBitContext start_state;
480 uint32_t tmp;
481 int trace, i;
482
483 4279 message = &current->messages[k];
484
485 // We write the payload twice in order to find the size. Trace
486 // output is switched off for the first write.
487 4279 trace = ctx->trace_enable;
488 4279 ctx->trace_enable = 0;
489
490 4279 start_state = *rw;
491 12837 for (i = 0; i < 2; i++) {
492 8558 *rw = start_state;
493
494 8558 tmp = message->payload_type;
495 8598 while (tmp >= 255) {
496 40 fixed(8, ff_byte, 0xff);
497 40 tmp -= 255;
498 }
499 8558 xu(8, last_payload_type_byte, tmp, 0, 254, 0);
500
501 8558 tmp = message->payload_size;
502 8604 while (tmp >= 255) {
503 46 fixed(8, ff_byte, 0xff);
504 46 tmp -= 255;
505 }
506 8558 xu(8, last_payload_size_byte, tmp, 0, 254, 0);
507
508 8558 err = FUNC(message)(ctx, rw, message);
509 8558 ctx->trace_enable = trace;
510 8558 if (err < 0)
511 ✗ return err;
512 }
513 }
514 #endif
515
516 10319 return 0;
517 }
518