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 "libavutil/avassert.h" | ||
20 | |||
21 | #include "cbs.h" | ||
22 | #include "cbs_internal.h" | ||
23 | #include "cbs_mpeg2.h" | ||
24 | #include "startcode.h" | ||
25 | |||
26 | |||
27 | #define HEADER(name) do { \ | ||
28 | ff_cbs_trace_header(ctx, name); \ | ||
29 | } while (0) | ||
30 | |||
31 | #define CHECK(call) do { \ | ||
32 | err = (call); \ | ||
33 | if (err < 0) \ | ||
34 | return err; \ | ||
35 | } while (0) | ||
36 | |||
37 | #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name | ||
38 | #define FUNC_MPEG2(rw, name) FUNC_NAME(rw, mpeg2, name) | ||
39 | #define FUNC(name) FUNC_MPEG2(READWRITE, name) | ||
40 | |||
41 | #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL) | ||
42 | |||
43 | #define ui(width, name) \ | ||
44 | xui(width, name, current->name, 0, MAX_UINT_BITS(width), 0, ) | ||
45 | #define uir(width, name) \ | ||
46 | xui(width, name, current->name, 1, MAX_UINT_BITS(width), 0, ) | ||
47 | #define uis(width, name, subs, ...) \ | ||
48 | xui(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__) | ||
49 | #define uirs(width, name, subs, ...) \ | ||
50 | xui(width, name, current->name, 1, MAX_UINT_BITS(width), subs, __VA_ARGS__) | ||
51 | #define xui(width, name, var, range_min, range_max, subs, ...) \ | ||
52 | xuia(width, #name, var, range_min, range_max, subs, __VA_ARGS__) | ||
53 | #define sis(width, name, subs, ...) \ | ||
54 | xsi(width, name, current->name, subs, __VA_ARGS__) | ||
55 | |||
56 | #define marker_bit() \ | ||
57 | bit("marker_bit", 1) | ||
58 | #define bit(string, value) do { \ | ||
59 | av_unused uint32_t bit = value; \ | ||
60 | xuia(1, string, bit, value, value, 0, ); \ | ||
61 | } while (0) | ||
62 | |||
63 | |||
64 | #define READ | ||
65 | #define READWRITE read | ||
66 | #define RWContext GetBitContext | ||
67 | |||
68 | #define xuia(width, string, var, range_min, range_max, subs, ...) do { \ | ||
69 | uint32_t value; \ | ||
70 | CHECK(ff_cbs_read_unsigned(ctx, rw, width, string, \ | ||
71 | SUBSCRIPTS(subs, __VA_ARGS__), \ | ||
72 | &value, range_min, range_max)); \ | ||
73 | var = value; \ | ||
74 | } while (0) | ||
75 | |||
76 | #define xsi(width, name, var, subs, ...) do { \ | ||
77 | int32_t value; \ | ||
78 | CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \ | ||
79 | SUBSCRIPTS(subs, __VA_ARGS__), &value, \ | ||
80 | MIN_INT_BITS(width), \ | ||
81 | MAX_INT_BITS(width))); \ | ||
82 | var = value; \ | ||
83 | } while (0) | ||
84 | |||
85 | #define nextbits(width, compare, var) \ | ||
86 | (get_bits_left(rw) >= width && \ | ||
87 | (var = show_bits(rw, width)) == (compare)) | ||
88 | |||
89 | #define infer(name, value) do { \ | ||
90 | current->name = value; \ | ||
91 | } while (0) | ||
92 | |||
93 | #include "cbs_mpeg2_syntax_template.c" | ||
94 | |||
95 | #undef READ | ||
96 | #undef READWRITE | ||
97 | #undef RWContext | ||
98 | #undef xuia | ||
99 | #undef xsi | ||
100 | #undef nextbits | ||
101 | #undef infer | ||
102 | |||
103 | |||
104 | #define WRITE | ||
105 | #define READWRITE write | ||
106 | #define RWContext PutBitContext | ||
107 | |||
108 | #define xuia(width, string, var, range_min, range_max, subs, ...) do { \ | ||
109 | CHECK(ff_cbs_write_unsigned(ctx, rw, width, string, \ | ||
110 | SUBSCRIPTS(subs, __VA_ARGS__), \ | ||
111 | var, range_min, range_max)); \ | ||
112 | } while (0) | ||
113 | |||
114 | #define xsi(width, name, var, subs, ...) do { \ | ||
115 | CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \ | ||
116 | SUBSCRIPTS(subs, __VA_ARGS__), var, \ | ||
117 | MIN_INT_BITS(width), \ | ||
118 | MAX_INT_BITS(width))); \ | ||
119 | } while (0) | ||
120 | |||
121 | #define nextbits(width, compare, var) (var) | ||
122 | |||
123 | #define infer(name, value) do { \ | ||
124 | if (current->name != (value)) { \ | ||
125 | av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \ | ||
126 | "%s does not match inferred value: " \ | ||
127 | "%"PRId64", but should be %"PRId64".\n", \ | ||
128 | #name, (int64_t)current->name, (int64_t)(value)); \ | ||
129 | } \ | ||
130 | } while (0) | ||
131 | |||
132 | #include "cbs_mpeg2_syntax_template.c" | ||
133 | |||
134 | #undef WRITE | ||
135 | #undef READWRITE | ||
136 | #undef RWContext | ||
137 | #undef xuia | ||
138 | #undef xsi | ||
139 | #undef nextbits | ||
140 | #undef infer | ||
141 | |||
142 | |||
143 | 18 | static int cbs_mpeg2_split_fragment(CodedBitstreamContext *ctx, | |
144 | CodedBitstreamFragment *frag, | ||
145 | int header) | ||
146 | { | ||
147 | const uint8_t *start; | ||
148 | 18 | uint32_t start_code = -1; | |
149 | int err; | ||
150 | |||
151 | 18 | start = avpriv_find_start_code(frag->data, frag->data + frag->data_size, | |
152 | &start_code); | ||
153 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
|
18 | if (start_code >> 8 != 0x000001) { |
154 | // No start code found. | ||
155 | ✗ | return AVERROR_INVALIDDATA; | |
156 | } | ||
157 | |||
158 | do { | ||
159 | 8843 | CodedBitstreamUnitType unit_type = start_code & 0xff; | |
160 | const uint8_t *end; | ||
161 | size_t unit_size; | ||
162 | |||
163 | // Reset start_code to ensure that avpriv_find_start_code() | ||
164 | // really reads a new start code and does not reuse the old | ||
165 | // start code in any way (as e.g. happens when there is a | ||
166 | // Sequence End unit at the very end of a packet). | ||
167 | 8843 | start_code = UINT32_MAX; | |
168 | 8843 | end = avpriv_find_start_code(start--, frag->data + frag->data_size, | |
169 | &start_code); | ||
170 | |||
171 | // start points to the byte containing the start_code_identifier | ||
172 | // (may be the last byte of fragment->data); end points to the byte | ||
173 | // following the byte containing the start code identifier (or to | ||
174 | // the end of fragment->data). | ||
175 |
2/2✓ Branch 0 taken 8825 times.
✓ Branch 1 taken 18 times.
|
8843 | if (start_code >> 8 == 0x000001) { |
176 | // Unit runs from start to the beginning of the start code | ||
177 | // pointed to by end (including any padding zeroes). | ||
178 | 8825 | unit_size = (end - 4) - start; | |
179 | } else { | ||
180 | // We didn't find a start code, so this is the final unit. | ||
181 | 18 | unit_size = end - start; | |
182 | } | ||
183 | |||
184 | 8843 | err = ff_cbs_append_unit_data(frag, unit_type, (uint8_t*)start, | |
185 | unit_size, frag->data_ref); | ||
186 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8843 times.
|
8843 | if (err < 0) |
187 | ✗ | return err; | |
188 | |||
189 | 8843 | start = end; | |
190 | |||
191 | // Do we have a further unit to add to the fragment? | ||
192 |
2/2✓ Branch 0 taken 8825 times.
✓ Branch 1 taken 18 times.
|
8843 | } while ((start_code >> 8) == 0x000001); |
193 | |||
194 | 18 | return 0; | |
195 | } | ||
196 | |||
197 | 8843 | static int cbs_mpeg2_read_unit(CodedBitstreamContext *ctx, | |
198 | CodedBitstreamUnit *unit) | ||
199 | { | ||
200 | GetBitContext gbc; | ||
201 | int err; | ||
202 | |||
203 | 8843 | err = init_get_bits(&gbc, unit->data, 8 * unit->data_size); | |
204 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8843 times.
|
8843 | if (err < 0) |
205 | ✗ | return err; | |
206 | |||
207 | 8843 | err = ff_cbs_alloc_unit_content(ctx, unit); | |
208 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8843 times.
|
8843 | if (err < 0) |
209 | ✗ | return err; | |
210 | |||
211 |
4/4✓ Branch 0 taken 8824 times.
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 8746 times.
✓ Branch 3 taken 78 times.
|
8843 | if (MPEG2_START_IS_SLICE(unit->type)) { |
212 | 8746 | MPEG2RawSlice *slice = unit->content; | |
213 | int pos, len; | ||
214 | |||
215 | 8746 | err = cbs_mpeg2_read_slice_header(ctx, &gbc, &slice->header); | |
216 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8746 times.
|
8746 | if (err < 0) |
217 | ✗ | return err; | |
218 | |||
219 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 8746 times.
|
8746 | if (!get_bits_left(&gbc)) |
220 | ✗ | return AVERROR_INVALIDDATA; | |
221 | |||
222 | 8746 | pos = get_bits_count(&gbc); | |
223 | 8746 | len = unit->data_size; | |
224 | |||
225 | 8746 | slice->data_size = len - pos / 8; | |
226 | 8746 | slice->data_ref = av_buffer_ref(unit->data_ref); | |
227 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8746 times.
|
8746 | if (!slice->data_ref) |
228 | ✗ | return AVERROR(ENOMEM); | |
229 | 8746 | slice->data = unit->data + pos / 8; | |
230 | |||
231 | 8746 | slice->data_bit_start = pos % 8; | |
232 | |||
233 | } else { | ||
234 |
6/7✓ Branch 0 taken 19 times.
✓ Branch 1 taken 14 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 53 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 3 times.
✗ Branch 6 not taken.
|
97 | switch (unit->type) { |
235 | #define START(start_code, type, read_func, free_func) \ | ||
236 | case start_code: \ | ||
237 | { \ | ||
238 | type *header = unit->content; \ | ||
239 | err = cbs_mpeg2_read_ ## read_func(ctx, &gbc, header); \ | ||
240 | if (err < 0) \ | ||
241 | return err; \ | ||
242 | } \ | ||
243 | break; | ||
244 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
|
19 | START(MPEG2_START_PICTURE, MPEG2RawPictureHeader, |
245 | picture_header, &cbs_mpeg2_free_picture_header); | ||
246 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
|
14 | START(MPEG2_START_USER_DATA, MPEG2RawUserData, |
247 | user_data, &cbs_mpeg2_free_user_data); | ||
248 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
|
6 | START(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader, |
249 | sequence_header, NULL); | ||
250 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 53 times.
|
53 | START(MPEG2_START_EXTENSION, MPEG2RawExtensionData, |
251 | extension_data, NULL); | ||
252 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
|
2 | START(MPEG2_START_GROUP, MPEG2RawGroupOfPicturesHeader, |
253 | group_of_pictures_header, NULL); | ||
254 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
|
3 | START(MPEG2_START_SEQUENCE_END, MPEG2RawSequenceEnd, |
255 | sequence_end, NULL); | ||
256 | #undef START | ||
257 | ✗ | default: | |
258 | ✗ | return AVERROR(ENOSYS); | |
259 | } | ||
260 | } | ||
261 | |||
262 | 8843 | return 0; | |
263 | } | ||
264 | |||
265 | 97 | static int cbs_mpeg2_write_header(CodedBitstreamContext *ctx, | |
266 | CodedBitstreamUnit *unit, | ||
267 | PutBitContext *pbc) | ||
268 | { | ||
269 | int err; | ||
270 | |||
271 |
6/7✓ Branch 0 taken 19 times.
✓ Branch 1 taken 14 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 53 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 3 times.
✗ Branch 6 not taken.
|
97 | switch (unit->type) { |
272 | #define START(start_code, type, func) \ | ||
273 | case start_code: \ | ||
274 | err = cbs_mpeg2_write_ ## func(ctx, pbc, unit->content); \ | ||
275 | break; | ||
276 | 19 | START(MPEG2_START_PICTURE, MPEG2RawPictureHeader, picture_header); | |
277 | 14 | START(MPEG2_START_USER_DATA, MPEG2RawUserData, user_data); | |
278 | 6 | START(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader, sequence_header); | |
279 | 53 | START(MPEG2_START_EXTENSION, MPEG2RawExtensionData, extension_data); | |
280 | 2 | START(MPEG2_START_GROUP, MPEG2RawGroupOfPicturesHeader, | |
281 | group_of_pictures_header); | ||
282 | 3 | START(MPEG2_START_SEQUENCE_END, MPEG2RawSequenceEnd, sequence_end); | |
283 | #undef START | ||
284 | ✗ | default: | |
285 | ✗ | av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for start " | |
286 | "code %02"PRIx32".\n", unit->type); | ||
287 | ✗ | return AVERROR_PATCHWELCOME; | |
288 | } | ||
289 | |||
290 | 97 | return err; | |
291 | } | ||
292 | |||
293 | 8746 | static int cbs_mpeg2_write_slice(CodedBitstreamContext *ctx, | |
294 | CodedBitstreamUnit *unit, | ||
295 | PutBitContext *pbc) | ||
296 | { | ||
297 | 8746 | MPEG2RawSlice *slice = unit->content; | |
298 | int err; | ||
299 | |||
300 | 8746 | err = cbs_mpeg2_write_slice_header(ctx, pbc, &slice->header); | |
301 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8746 times.
|
8746 | if (err < 0) |
302 | ✗ | return err; | |
303 | |||
304 |
1/2✓ Branch 0 taken 8746 times.
✗ Branch 1 not taken.
|
8746 | if (slice->data) { |
305 | 8746 | size_t rest = slice->data_size - (slice->data_bit_start + 7) / 8; | |
306 | 8746 | uint8_t *pos = slice->data + slice->data_bit_start / 8; | |
307 | |||
308 |
2/4✓ Branch 0 taken 8746 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 8746 times.
|
8746 | av_assert0(slice->data_bit_start >= 0 && |
309 | slice->data_size > slice->data_bit_start / 8); | ||
310 | |||
311 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 8746 times.
|
8746 | if (slice->data_size * 8 + 8 > put_bits_left(pbc)) |
312 | ✗ | return AVERROR(ENOSPC); | |
313 | |||
314 | // First copy the remaining bits of the first byte | ||
315 |
1/2✓ Branch 0 taken 8746 times.
✗ Branch 1 not taken.
|
8746 | if (slice->data_bit_start % 8) |
316 | 8746 | put_bits(pbc, 8 - slice->data_bit_start % 8, | |
317 | 8746 | *pos++ & MAX_UINT_BITS(8 - slice->data_bit_start % 8)); | |
318 | |||
319 |
1/2✓ Branch 1 taken 8746 times.
✗ Branch 2 not taken.
|
8746 | if (put_bits_count(pbc) % 8 == 0) { |
320 | // If the writer is aligned at this point, | ||
321 | // memcpy can be used to improve performance. | ||
322 | // This is the normal case. | ||
323 | 8746 | flush_put_bits(pbc); | |
324 | 8746 | memcpy(put_bits_ptr(pbc), pos, rest); | |
325 | 8746 | skip_put_bytes(pbc, rest); | |
326 | } else { | ||
327 | // If not, we have to copy manually: | ||
328 | ✗ | for (; rest > 3; rest -= 4, pos += 4) | |
329 | ✗ | put_bits32(pbc, AV_RB32(pos)); | |
330 | |||
331 | ✗ | for (; rest; rest--, pos++) | |
332 | ✗ | put_bits(pbc, 8, *pos); | |
333 | |||
334 | // Align with zeros | ||
335 | ✗ | put_bits(pbc, 8 - put_bits_count(pbc) % 8, 0); | |
336 | } | ||
337 | } | ||
338 | |||
339 | 8746 | return 0; | |
340 | } | ||
341 | |||
342 | 8843 | static int cbs_mpeg2_write_unit(CodedBitstreamContext *ctx, | |
343 | CodedBitstreamUnit *unit, | ||
344 | PutBitContext *pbc) | ||
345 | { | ||
346 |
4/4✓ Branch 0 taken 8824 times.
✓ Branch 1 taken 19 times.
✓ Branch 2 taken 8746 times.
✓ Branch 3 taken 78 times.
|
8843 | if (MPEG2_START_IS_SLICE(unit->type)) |
347 | 8746 | return cbs_mpeg2_write_slice (ctx, unit, pbc); | |
348 | else | ||
349 | 97 | return cbs_mpeg2_write_header(ctx, unit, pbc); | |
350 | } | ||
351 | |||
352 | 18 | static int cbs_mpeg2_assemble_fragment(CodedBitstreamContext *ctx, | |
353 | CodedBitstreamFragment *frag) | ||
354 | { | ||
355 | uint8_t *data; | ||
356 | size_t size, dp; | ||
357 | int i; | ||
358 | |||
359 | 18 | size = 0; | |
360 |
2/2✓ Branch 0 taken 8843 times.
✓ Branch 1 taken 18 times.
|
8861 | for (i = 0; i < frag->nb_units; i++) |
361 | 8843 | size += 3 + frag->units[i].data_size; | |
362 | |||
363 | 18 | frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE); | |
364 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
|
18 | if (!frag->data_ref) |
365 | ✗ | return AVERROR(ENOMEM); | |
366 | 18 | data = frag->data_ref->data; | |
367 | |||
368 | 18 | dp = 0; | |
369 |
2/2✓ Branch 0 taken 8843 times.
✓ Branch 1 taken 18 times.
|
8861 | for (i = 0; i < frag->nb_units; i++) { |
370 | 8843 | CodedBitstreamUnit *unit = &frag->units[i]; | |
371 | |||
372 | 8843 | data[dp++] = 0; | |
373 | 8843 | data[dp++] = 0; | |
374 | 8843 | data[dp++] = 1; | |
375 | |||
376 | 8843 | memcpy(data + dp, unit->data, unit->data_size); | |
377 | 8843 | dp += unit->data_size; | |
378 | } | ||
379 | |||
380 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
|
18 | av_assert0(dp == size); |
381 | |||
382 | 18 | memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE); | |
383 | 18 | frag->data = data; | |
384 | 18 | frag->data_size = size; | |
385 | |||
386 | 18 | return 0; | |
387 | } | ||
388 | |||
389 | static const CodedBitstreamUnitTypeDescriptor cbs_mpeg2_unit_types[] = { | ||
390 | CBS_UNIT_TYPE_INTERNAL_REF(MPEG2_START_PICTURE, MPEG2RawPictureHeader, | ||
391 | extra_information_picture.extra_information), | ||
392 | |||
393 | { | ||
394 | .nb_unit_types = CBS_UNIT_TYPE_RANGE, | ||
395 | .unit_type.range.start = 0x01, | ||
396 | .unit_type.range.end = 0xaf, | ||
397 | |||
398 | .content_type = CBS_CONTENT_TYPE_INTERNAL_REFS, | ||
399 | .content_size = sizeof(MPEG2RawSlice), | ||
400 | .type.ref = { .nb_offsets = 2, | ||
401 | .offsets = { offsetof(MPEG2RawSlice, header.extra_information_slice.extra_information), | ||
402 | offsetof(MPEG2RawSlice, data) } }, | ||
403 | }, | ||
404 | |||
405 | CBS_UNIT_TYPE_INTERNAL_REF(MPEG2_START_USER_DATA, MPEG2RawUserData, | ||
406 | user_data), | ||
407 | |||
408 | CBS_UNIT_TYPE_POD(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader), | ||
409 | CBS_UNIT_TYPE_POD(MPEG2_START_EXTENSION, MPEG2RawExtensionData), | ||
410 | CBS_UNIT_TYPE_POD(MPEG2_START_SEQUENCE_END, MPEG2RawSequenceEnd), | ||
411 | CBS_UNIT_TYPE_POD(MPEG2_START_GROUP, MPEG2RawGroupOfPicturesHeader), | ||
412 | |||
413 | CBS_UNIT_TYPE_END_OF_LIST | ||
414 | }; | ||
415 | |||
416 | const CodedBitstreamType ff_cbs_type_mpeg2 = { | ||
417 | .codec_id = AV_CODEC_ID_MPEG2VIDEO, | ||
418 | |||
419 | .priv_data_size = sizeof(CodedBitstreamMPEG2Context), | ||
420 | |||
421 | .unit_types = cbs_mpeg2_unit_types, | ||
422 | |||
423 | .split_fragment = &cbs_mpeg2_split_fragment, | ||
424 | .read_unit = &cbs_mpeg2_read_unit, | ||
425 | .write_unit = &cbs_mpeg2_write_unit, | ||
426 | .assemble_fragment = &cbs_mpeg2_assemble_fragment, | ||
427 | }; | ||
428 |