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 "cbs.h" | ||
20 | #include "cbs_internal.h" | ||
21 | #include "cbs_h264.h" | ||
22 | #include "cbs_h265.h" | ||
23 | #include "cbs_h266.h" | ||
24 | #include "cbs_sei.h" | ||
25 | |||
26 | 25 | static void cbs_free_user_data_registered(void *opaque, uint8_t *data) | |
27 | { | ||
28 | 25 | SEIRawUserDataRegistered *udr = (SEIRawUserDataRegistered*)data; | |
29 | 25 | av_buffer_unref(&udr->data_ref); | |
30 | 25 | av_free(udr); | |
31 | 25 | } | |
32 | |||
33 | 20 | static void cbs_free_user_data_unregistered(void *opaque, uint8_t *data) | |
34 | { | ||
35 | 20 | SEIRawUserDataUnregistered *udu = (SEIRawUserDataUnregistered*)data; | |
36 | 20 | av_buffer_unref(&udu->data_ref); | |
37 | 20 | av_free(udu); | |
38 | 20 | } | |
39 | |||
40 | 4783 | int ff_cbs_sei_alloc_message_payload(SEIRawMessage *message, | |
41 | const SEIMessageTypeDescriptor *desc) | ||
42 | { | ||
43 | void (*free_func)(void*, uint8_t*); | ||
44 | |||
45 |
2/4✓ Branch 0 taken 4783 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4783 times.
|
4783 | av_assert0(message->payload == NULL && |
46 | message->payload_ref == NULL); | ||
47 | 4783 | message->payload_type = desc->type; | |
48 | |||
49 |
2/2✓ Branch 0 taken 25 times.
✓ Branch 1 taken 4758 times.
|
4783 | if (desc->type == SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35) |
50 | 25 | free_func = &cbs_free_user_data_registered; | |
51 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 4738 times.
|
4758 | else if (desc->type == SEI_TYPE_USER_DATA_UNREGISTERED) |
52 | 20 | free_func = &cbs_free_user_data_unregistered; | |
53 | else | ||
54 | 4738 | free_func = NULL; | |
55 | |||
56 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 4738 times.
|
4783 | if (free_func) { |
57 | 45 | message->payload = av_mallocz(desc->size); | |
58 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 45 times.
|
45 | if (!message->payload) |
59 | ✗ | return AVERROR(ENOMEM); | |
60 | 45 | message->payload_ref = | |
61 | 45 | av_buffer_create(message->payload, desc->size, | |
62 | free_func, NULL, 0); | ||
63 | } else { | ||
64 | 4738 | message->payload_ref = av_buffer_alloc(desc->size); | |
65 | } | ||
66 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4783 times.
|
4783 | if (!message->payload_ref) { |
67 | ✗ | av_freep(&message->payload); | |
68 | ✗ | return AVERROR(ENOMEM); | |
69 | } | ||
70 | 4783 | message->payload = message->payload_ref->data; | |
71 | |||
72 | 4783 | return 0; | |
73 | } | ||
74 | |||
75 | 4850 | int ff_cbs_sei_list_add(SEIRawMessageList *list) | |
76 | { | ||
77 | void *ptr; | ||
78 | 4850 | int old_count = list->nb_messages_allocated; | |
79 | |||
80 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4850 times.
|
4850 | av_assert0(list->nb_messages <= old_count); |
81 |
2/2✓ Branch 0 taken 4841 times.
✓ Branch 1 taken 9 times.
|
4850 | if (list->nb_messages + 1 > old_count) { |
82 | 4841 | int new_count = 2 * old_count + 1; | |
83 | |||
84 | 4841 | ptr = av_realloc_array(list->messages, | |
85 | new_count, sizeof(*list->messages)); | ||
86 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4841 times.
|
4841 | if (!ptr) |
87 | ✗ | return AVERROR(ENOMEM); | |
88 | |||
89 | 4841 | list->messages = ptr; | |
90 | 4841 | list->nb_messages_allocated = new_count; | |
91 | |||
92 | // Zero the newly-added entries. | ||
93 | 4841 | memset(list->messages + old_count, 0, | |
94 | 4841 | (new_count - old_count) * sizeof(*list->messages)); | |
95 | } | ||
96 | 4850 | ++list->nb_messages; | |
97 | 4850 | return 0; | |
98 | } | ||
99 | |||
100 | 4830 | void ff_cbs_sei_free_message_list(SEIRawMessageList *list) | |
101 | { | ||
102 |
2/2✓ Branch 0 taken 4850 times.
✓ Branch 1 taken 4830 times.
|
9680 | for (int i = 0; i < list->nb_messages; i++) { |
103 | 4850 | SEIRawMessage *message = &list->messages[i]; | |
104 | 4850 | av_buffer_unref(&message->payload_ref); | |
105 | 4850 | av_buffer_unref(&message->extension_data_ref); | |
106 | } | ||
107 | 4830 | av_free(list->messages); | |
108 | 4830 | } | |
109 | |||
110 | ✗ | static int cbs_sei_get_unit(CodedBitstreamContext *ctx, | |
111 | CodedBitstreamFragment *au, | ||
112 | int prefix, | ||
113 | CodedBitstreamUnit **sei_unit) | ||
114 | { | ||
115 | CodedBitstreamUnit *unit; | ||
116 | int sei_type, highest_vcl_type, err, i, position; | ||
117 | |||
118 | ✗ | switch (ctx->codec->codec_id) { | |
119 | ✗ | case AV_CODEC_ID_H264: | |
120 | // (We can ignore auxiliary slices because we only have prefix | ||
121 | // SEI in H.264 and an auxiliary picture must always follow a | ||
122 | // primary picture.) | ||
123 | ✗ | highest_vcl_type = H264_NAL_IDR_SLICE; | |
124 | ✗ | if (prefix) | |
125 | ✗ | sei_type = H264_NAL_SEI; | |
126 | else | ||
127 | ✗ | return AVERROR(EINVAL); | |
128 | ✗ | break; | |
129 | ✗ | case AV_CODEC_ID_H265: | |
130 | ✗ | highest_vcl_type = HEVC_NAL_RSV_VCL31; | |
131 | ✗ | if (prefix) | |
132 | ✗ | sei_type = HEVC_NAL_SEI_PREFIX; | |
133 | else | ||
134 | ✗ | sei_type = HEVC_NAL_SEI_SUFFIX; | |
135 | ✗ | break; | |
136 | ✗ | case AV_CODEC_ID_H266: | |
137 | ✗ | highest_vcl_type = VVC_RSV_IRAP_11; | |
138 | ✗ | if (prefix) | |
139 | ✗ | sei_type = VVC_PREFIX_SEI_NUT; | |
140 | else | ||
141 | ✗ | sei_type = VVC_SUFFIX_SEI_NUT; | |
142 | ✗ | break; | |
143 | ✗ | default: | |
144 | ✗ | return AVERROR(EINVAL); | |
145 | } | ||
146 | |||
147 | // Find an existing SEI NAL unit of the right type. | ||
148 | ✗ | unit = NULL; | |
149 | ✗ | for (i = 0; i < au->nb_units; i++) { | |
150 | ✗ | if (au->units[i].type == sei_type) { | |
151 | ✗ | unit = &au->units[i]; | |
152 | ✗ | break; | |
153 | } | ||
154 | } | ||
155 | |||
156 | ✗ | if (unit) { | |
157 | ✗ | *sei_unit = unit; | |
158 | ✗ | return 0; | |
159 | } | ||
160 | |||
161 | // Need to add a new SEI NAL unit ... | ||
162 | ✗ | if (prefix) { | |
163 | // ... before the first VCL NAL unit. | ||
164 | ✗ | for (i = 0; i < au->nb_units; i++) { | |
165 | ✗ | if (au->units[i].type < highest_vcl_type) | |
166 | ✗ | break; | |
167 | } | ||
168 | ✗ | position = i; | |
169 | } else { | ||
170 | // ... after the last VCL NAL unit. | ||
171 | ✗ | for (i = au->nb_units - 1; i >= 0; i--) { | |
172 | ✗ | if (au->units[i].type < highest_vcl_type) | |
173 | ✗ | break; | |
174 | } | ||
175 | ✗ | if (i < 0) { | |
176 | // No VCL units; just put it at the end. | ||
177 | ✗ | position = au->nb_units; | |
178 | } else { | ||
179 | ✗ | position = i + 1; | |
180 | } | ||
181 | } | ||
182 | |||
183 | ✗ | err = ff_cbs_insert_unit_content(au, position, sei_type, | |
184 | NULL, NULL); | ||
185 | ✗ | if (err < 0) | |
186 | ✗ | return err; | |
187 | ✗ | unit = &au->units[position]; | |
188 | ✗ | unit->type = sei_type; | |
189 | |||
190 | ✗ | err = ff_cbs_alloc_unit_content(ctx, unit); | |
191 | ✗ | if (err < 0) | |
192 | ✗ | return err; | |
193 | |||
194 | ✗ | switch (ctx->codec->codec_id) { | |
195 | ✗ | case AV_CODEC_ID_H264: | |
196 | { | ||
197 | ✗ | H264RawSEI sei = { | |
198 | .nal_unit_header = { | ||
199 | .nal_ref_idc = 0, | ||
200 | .nal_unit_type = sei_type, | ||
201 | }, | ||
202 | }; | ||
203 | ✗ | memcpy(unit->content, &sei, sizeof(sei)); | |
204 | } | ||
205 | ✗ | break; | |
206 | ✗ | case AV_CODEC_ID_H265: | |
207 | { | ||
208 | ✗ | H265RawSEI sei = { | |
209 | .nal_unit_header = { | ||
210 | .nal_unit_type = sei_type, | ||
211 | .nuh_layer_id = 0, | ||
212 | .nuh_temporal_id_plus1 = 1, | ||
213 | }, | ||
214 | }; | ||
215 | ✗ | memcpy(unit->content, &sei, sizeof(sei)); | |
216 | } | ||
217 | ✗ | break; | |
218 | ✗ | case AV_CODEC_ID_H266: | |
219 | { | ||
220 | ✗ | H266RawSEI sei = { | |
221 | .nal_unit_header = { | ||
222 | .nal_unit_type = sei_type, | ||
223 | .nuh_layer_id = 0, | ||
224 | .nuh_temporal_id_plus1 = 1, | ||
225 | }, | ||
226 | }; | ||
227 | ✗ | memcpy(unit->content, &sei, sizeof(sei)); | |
228 | } | ||
229 | ✗ | break; | |
230 | ✗ | default: | |
231 | ✗ | av_assert0(0); | |
232 | } | ||
233 | |||
234 | ✗ | *sei_unit = unit; | |
235 | ✗ | return 0; | |
236 | } | ||
237 | |||
238 | 104 | static int cbs_sei_get_message_list(CodedBitstreamContext *ctx, | |
239 | CodedBitstreamUnit *unit, | ||
240 | SEIRawMessageList **list) | ||
241 | { | ||
242 |
1/4✓ Branch 0 taken 104 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
104 | switch (ctx->codec->codec_id) { |
243 | 104 | case AV_CODEC_ID_H264: | |
244 | { | ||
245 | 104 | H264RawSEI *sei = unit->content; | |
246 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 61 times.
|
104 | if (unit->type != H264_NAL_SEI) |
247 | 43 | return AVERROR(EINVAL); | |
248 | 61 | *list = &sei->message_list; | |
249 | } | ||
250 | 61 | break; | |
251 | ✗ | case AV_CODEC_ID_H265: | |
252 | { | ||
253 | ✗ | H265RawSEI *sei = unit->content; | |
254 | ✗ | if (unit->type != HEVC_NAL_SEI_PREFIX && | |
255 | ✗ | unit->type != HEVC_NAL_SEI_SUFFIX) | |
256 | ✗ | return AVERROR(EINVAL); | |
257 | ✗ | *list = &sei->message_list; | |
258 | } | ||
259 | ✗ | break; | |
260 | ✗ | case AV_CODEC_ID_H266: | |
261 | { | ||
262 | ✗ | H266RawSEI *sei = unit->content; | |
263 | ✗ | if (unit->type != VVC_PREFIX_SEI_NUT && | |
264 | ✗ | unit->type != VVC_SUFFIX_SEI_NUT) | |
265 | ✗ | return AVERROR(EINVAL); | |
266 | ✗ | *list = &sei->message_list; | |
267 | } | ||
268 | ✗ | break; | |
269 | ✗ | default: | |
270 | ✗ | return AVERROR(EINVAL); | |
271 | } | ||
272 | |||
273 | 61 | return 0; | |
274 | } | ||
275 | |||
276 | ✗ | int ff_cbs_sei_add_message(CodedBitstreamContext *ctx, | |
277 | CodedBitstreamFragment *au, | ||
278 | int prefix, | ||
279 | uint32_t payload_type, | ||
280 | void *payload_data, | ||
281 | AVBufferRef *payload_buf) | ||
282 | { | ||
283 | const SEIMessageTypeDescriptor *desc; | ||
284 | CodedBitstreamUnit *unit; | ||
285 | SEIRawMessageList *list; | ||
286 | SEIRawMessage *message; | ||
287 | AVBufferRef *payload_ref; | ||
288 | int err; | ||
289 | |||
290 | ✗ | desc = ff_cbs_sei_find_type(ctx, payload_type); | |
291 | ✗ | if (!desc) | |
292 | ✗ | return AVERROR(EINVAL); | |
293 | |||
294 | // Find an existing SEI unit or make a new one to add to. | ||
295 | ✗ | err = cbs_sei_get_unit(ctx, au, prefix, &unit); | |
296 | ✗ | if (err < 0) | |
297 | ✗ | return err; | |
298 | |||
299 | // Find the message list inside the codec-dependent unit. | ||
300 | ✗ | err = cbs_sei_get_message_list(ctx, unit, &list); | |
301 | ✗ | if (err < 0) | |
302 | ✗ | return err; | |
303 | |||
304 | // Add a new message to the message list. | ||
305 | ✗ | err = ff_cbs_sei_list_add(list); | |
306 | ✗ | if (err < 0) | |
307 | ✗ | return err; | |
308 | |||
309 | ✗ | if (payload_buf) { | |
310 | ✗ | payload_ref = av_buffer_ref(payload_buf); | |
311 | ✗ | if (!payload_ref) | |
312 | ✗ | return AVERROR(ENOMEM); | |
313 | } else { | ||
314 | ✗ | payload_ref = NULL; | |
315 | } | ||
316 | |||
317 | ✗ | message = &list->messages[list->nb_messages - 1]; | |
318 | |||
319 | ✗ | message->payload_type = payload_type; | |
320 | ✗ | message->payload = payload_data; | |
321 | ✗ | message->payload_ref = payload_ref; | |
322 | |||
323 | ✗ | return 0; | |
324 | } | ||
325 | |||
326 | ✗ | int ff_cbs_sei_find_message(CodedBitstreamContext *ctx, | |
327 | CodedBitstreamFragment *au, | ||
328 | uint32_t payload_type, | ||
329 | SEIRawMessage **iter) | ||
330 | { | ||
331 | int err, i, j, found; | ||
332 | |||
333 | ✗ | found = 0; | |
334 | ✗ | for (i = 0; i < au->nb_units; i++) { | |
335 | ✗ | CodedBitstreamUnit *unit = &au->units[i]; | |
336 | SEIRawMessageList *list; | ||
337 | |||
338 | ✗ | err = cbs_sei_get_message_list(ctx, unit, &list); | |
339 | ✗ | if (err < 0) | |
340 | ✗ | continue; | |
341 | |||
342 | ✗ | for (j = 0; j < list->nb_messages; j++) { | |
343 | ✗ | SEIRawMessage *message = &list->messages[j]; | |
344 | |||
345 | ✗ | if (message->payload_type == payload_type) { | |
346 | ✗ | if (!*iter || found) { | |
347 | ✗ | *iter = message; | |
348 | ✗ | return 0; | |
349 | } | ||
350 | ✗ | if (message == *iter) | |
351 | ✗ | found = 1; | |
352 | } | ||
353 | } | ||
354 | } | ||
355 | |||
356 | ✗ | return AVERROR(ENOENT); | |
357 | } | ||
358 | |||
359 | ✗ | static void cbs_sei_delete_message(SEIRawMessageList *list, | |
360 | int position) | ||
361 | { | ||
362 | SEIRawMessage *message; | ||
363 | |||
364 | ✗ | av_assert0(0 <= position && position < list->nb_messages); | |
365 | |||
366 | ✗ | message = &list->messages[position]; | |
367 | ✗ | av_buffer_unref(&message->payload_ref); | |
368 | ✗ | av_buffer_unref(&message->extension_data_ref); | |
369 | |||
370 | ✗ | --list->nb_messages; | |
371 | |||
372 | ✗ | if (list->nb_messages > 0) { | |
373 | ✗ | memmove(list->messages + position, | |
374 | ✗ | list->messages + position + 1, | |
375 | ✗ | (list->nb_messages - position) * sizeof(*list->messages)); | |
376 | } | ||
377 | ✗ | } | |
378 | |||
379 | 40 | void ff_cbs_sei_delete_message_type(CodedBitstreamContext *ctx, | |
380 | CodedBitstreamFragment *au, | ||
381 | uint32_t payload_type) | ||
382 | { | ||
383 | int err, i, j; | ||
384 | |||
385 |
2/2✓ Branch 0 taken 104 times.
✓ Branch 1 taken 40 times.
|
144 | for (i = 0; i < au->nb_units; i++) { |
386 | 104 | CodedBitstreamUnit *unit = &au->units[i]; | |
387 | SEIRawMessageList *list; | ||
388 | |||
389 | 104 | err = cbs_sei_get_message_list(ctx, unit, &list); | |
390 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 61 times.
|
104 | if (err < 0) |
391 | 43 | continue; | |
392 | |||
393 |
2/2✓ Branch 0 taken 61 times.
✓ Branch 1 taken 61 times.
|
122 | for (j = list->nb_messages - 1; j >= 0; j--) { |
394 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61 times.
|
61 | if (list->messages[j].payload_type == payload_type) |
395 | ✗ | cbs_sei_delete_message(list, j); | |
396 | } | ||
397 | } | ||
398 | 40 | } | |
399 |