a8d252f6c20f6862aa4d52e059a16bdf6fa7d334
[libav.git] / libavcodec / cbs.c
1 /*
2 * This file is part of Libav.
3 *
4 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <string.h>
20
21 #include "config.h"
22
23 #include "libavutil/avassert.h"
24 #include "libavutil/common.h"
25
26 #include "cbs.h"
27 #include "cbs_internal.h"
28
29
30 static const CodedBitstreamType *cbs_type_table[] = {
31 #if CONFIG_CBS_H264
32 &ff_cbs_type_h264,
33 #endif
34 #if CONFIG_CBS_H265
35 &ff_cbs_type_h265,
36 #endif
37 #if CONFIG_CBS_MPEG2
38 &ff_cbs_type_mpeg2,
39 #endif
40 };
41
42 int ff_cbs_init(CodedBitstreamContext **ctx_ptr,
43 enum AVCodecID codec_id, void *log_ctx)
44 {
45 CodedBitstreamContext *ctx;
46 const CodedBitstreamType *type;
47 int i;
48
49 type = NULL;
50 for (i = 0; i < FF_ARRAY_ELEMS(cbs_type_table); i++) {
51 if (cbs_type_table[i]->codec_id == codec_id) {
52 type = cbs_type_table[i];
53 break;
54 }
55 }
56 if (!type)
57 return AVERROR(EINVAL);
58
59 ctx = av_mallocz(sizeof(*ctx));
60 if (!ctx)
61 return AVERROR(ENOMEM);
62
63 ctx->log_ctx = log_ctx;
64 ctx->codec = type;
65
66 ctx->priv_data = av_mallocz(ctx->codec->priv_data_size);
67 if (!ctx->priv_data) {
68 av_freep(&ctx);
69 return AVERROR(ENOMEM);
70 }
71
72 ctx->decompose_unit_types = NULL;
73
74 ctx->trace_enable = 0;
75 ctx->trace_level = AV_LOG_TRACE;
76
77 *ctx_ptr = ctx;
78 return 0;
79 }
80
81 void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
82 {
83 CodedBitstreamContext *ctx = *ctx_ptr;
84
85 if (!ctx)
86 return;
87
88 if (ctx->codec && ctx->codec->close)
89 ctx->codec->close(ctx);
90
91 av_freep(&ctx->priv_data);
92 av_freep(ctx_ptr);
93 }
94
95 static void cbs_unit_uninit(CodedBitstreamContext *ctx,
96 CodedBitstreamUnit *unit)
97 {
98 if (ctx->codec->free_unit && unit->content && !unit->content_external)
99 ctx->codec->free_unit(unit);
100
101 av_freep(&unit->data);
102 unit->data_size = 0;
103 unit->data_bit_padding = 0;
104 }
105
106 void ff_cbs_fragment_uninit(CodedBitstreamContext *ctx,
107 CodedBitstreamFragment *frag)
108 {
109 int i;
110
111 for (i = 0; i < frag->nb_units; i++)
112 cbs_unit_uninit(ctx, &frag->units[i]);
113 av_freep(&frag->units);
114 frag->nb_units = 0;
115
116 av_freep(&frag->data);
117 frag->data_size = 0;
118 frag->data_bit_padding = 0;
119 }
120
121 static int cbs_read_fragment_content(CodedBitstreamContext *ctx,
122 CodedBitstreamFragment *frag)
123 {
124 int err, i, j;
125
126 for (i = 0; i < frag->nb_units; i++) {
127 if (ctx->decompose_unit_types) {
128 for (j = 0; j < ctx->nb_decompose_unit_types; j++) {
129 if (ctx->decompose_unit_types[j] == frag->units[i].type)
130 break;
131 }
132 if (j >= ctx->nb_decompose_unit_types)
133 continue;
134 }
135
136 err = ctx->codec->read_unit(ctx, &frag->units[i]);
137 if (err == AVERROR(ENOSYS)) {
138 av_log(ctx->log_ctx, AV_LOG_VERBOSE,
139 "Decomposition unimplemented for unit %d "
140 "(type %"PRIu32").\n", i, frag->units[i].type);
141 } else if (err < 0) {
142 av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to read unit %d "
143 "(type %"PRIu32").\n", i, frag->units[i].type);
144 return err;
145 }
146 }
147
148 return 0;
149 }
150
151 int ff_cbs_read_extradata(CodedBitstreamContext *ctx,
152 CodedBitstreamFragment *frag,
153 const AVCodecParameters *par)
154 {
155 int err;
156
157 memset(frag, 0, sizeof(*frag));
158
159 frag->data = par->extradata;
160 frag->data_size = par->extradata_size;
161
162 err = ctx->codec->split_fragment(ctx, frag, 1);
163 if (err < 0)
164 return err;
165
166 frag->data = NULL;
167 frag->data_size = 0;
168
169 return cbs_read_fragment_content(ctx, frag);
170 }
171
172 int ff_cbs_read_packet(CodedBitstreamContext *ctx,
173 CodedBitstreamFragment *frag,
174 const AVPacket *pkt)
175 {
176 int err;
177
178 memset(frag, 0, sizeof(*frag));
179
180 frag->data = pkt->data;
181 frag->data_size = pkt->size;
182
183 err = ctx->codec->split_fragment(ctx, frag, 0);
184 if (err < 0)
185 return err;
186
187 frag->data = NULL;
188 frag->data_size = 0;
189
190 return cbs_read_fragment_content(ctx, frag);
191 }
192
193 int ff_cbs_read(CodedBitstreamContext *ctx,
194 CodedBitstreamFragment *frag,
195 const uint8_t *data, size_t size)
196 {
197 int err;
198
199 memset(frag, 0, sizeof(*frag));
200
201 // (We won't write to this during split.)
202 frag->data = (uint8_t*)data;
203 frag->data_size = size;
204
205 err = ctx->codec->split_fragment(ctx, frag, 0);
206 if (err < 0)
207 return err;
208
209 frag->data = NULL;
210 frag->data_size = 0;
211
212 return cbs_read_fragment_content(ctx, frag);
213 }
214
215
216 int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx,
217 CodedBitstreamFragment *frag)
218 {
219 int err, i;
220
221 for (i = 0; i < frag->nb_units; i++) {
222 if (!frag->units[i].content)
223 continue;
224
225 err = ctx->codec->write_unit(ctx, &frag->units[i]);
226 if (err < 0) {
227 av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write unit %d "
228 "(type %"PRIu32").\n", i, frag->units[i].type);
229 return err;
230 }
231 }
232
233 err = ctx->codec->assemble_fragment(ctx, frag);
234 if (err < 0) {
235 av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to assemble fragment.\n");
236 return err;
237 }
238
239 return 0;
240 }
241
242 int ff_cbs_write_extradata(CodedBitstreamContext *ctx,
243 AVCodecParameters *par,
244 CodedBitstreamFragment *frag)
245 {
246 int err;
247
248 err = ff_cbs_write_fragment_data(ctx, frag);
249 if (err < 0)
250 return err;
251
252 av_freep(&par->extradata);
253
254 par->extradata = av_malloc(frag->data_size +
255 AV_INPUT_BUFFER_PADDING_SIZE);
256 if (!par->extradata)
257 return AVERROR(ENOMEM);
258
259 memcpy(par->extradata, frag->data, frag->data_size);
260 memset(par->extradata + frag->data_size, 0,
261 AV_INPUT_BUFFER_PADDING_SIZE);
262 par->extradata_size = frag->data_size;
263
264 return 0;
265 }
266
267 int ff_cbs_write_packet(CodedBitstreamContext *ctx,
268 AVPacket *pkt,
269 CodedBitstreamFragment *frag)
270 {
271 int err;
272
273 err = ff_cbs_write_fragment_data(ctx, frag);
274 if (err < 0)
275 return err;
276
277 err = av_new_packet(pkt, frag->data_size);
278 if (err < 0)
279 return err;
280
281 memcpy(pkt->data, frag->data, frag->data_size);
282 pkt->size = frag->data_size;
283
284 return 0;
285 }
286
287
288 void ff_cbs_trace_header(CodedBitstreamContext *ctx,
289 const char *name)
290 {
291 if (!ctx->trace_enable)
292 return;
293
294 av_log(ctx->log_ctx, ctx->trace_level, "%s\n", name);
295 }
296
297 void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position,
298 const char *name, const char *bits,
299 int64_t value)
300 {
301 size_t name_len, bits_len;
302 int pad;
303
304 if (!ctx->trace_enable)
305 return;
306
307 av_assert0(value >= INT_MIN && value <= UINT32_MAX);
308
309 name_len = strlen(name);
310 bits_len = strlen(bits);
311
312 if (name_len + bits_len > 60)
313 pad = bits_len + 2;
314 else
315 pad = 61 - name_len;
316
317 av_log(ctx->log_ctx, ctx->trace_level, "%-10d %s%*s = %"PRId64"\n",
318 position, name, pad, bits, value);
319 }
320
321 int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, BitstreamContext *bc,
322 int width, const char *name, uint32_t *write_to,
323 uint32_t range_min, uint32_t range_max)
324 {
325 uint32_t value;
326 int position;
327
328 av_assert0(width <= 32);
329
330 if (bitstream_bits_left(bc) < width) {
331 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
332 "%s: bitstream ended.\n", name);
333 return AVERROR_INVALIDDATA;
334 }
335
336 if (ctx->trace_enable)
337 position = bitstream_tell(bc);
338
339 value = bitstream_read(bc, width);
340
341 if (ctx->trace_enable) {
342 char bits[33];
343 int i;
344 for (i = 0; i < width; i++)
345 bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
346 bits[i] = 0;
347
348 ff_cbs_trace_syntax_element(ctx, position, name, bits, value);
349 }
350
351 if (value < range_min || value > range_max) {
352 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
353 "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
354 name, value, range_min, range_max);
355 return AVERROR_INVALIDDATA;
356 }
357
358 *write_to = value;
359 return 0;
360 }
361
362 int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc,
363 int width, const char *name, uint32_t value,
364 uint32_t range_min, uint32_t range_max)
365 {
366 av_assert0(width <= 32);
367
368 if (value < range_min || value > range_max) {
369 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
370 "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
371 name, value, range_min, range_max);
372 return AVERROR_INVALIDDATA;
373 }
374
375 if (put_bits_left(pbc) < width)
376 return AVERROR(ENOSPC);
377
378 if (ctx->trace_enable) {
379 char bits[33];
380 int i;
381 for (i = 0; i < width; i++)
382 bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
383 bits[i] = 0;
384
385 ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc), name, bits, value);
386 }
387
388 if (width < 32)
389 put_bits(pbc, width, value);
390 else
391 put_bits32(pbc, value);
392
393 return 0;
394 }
395
396
397 static int cbs_insert_unit(CodedBitstreamContext *ctx,
398 CodedBitstreamFragment *frag,
399 int position)
400 {
401 CodedBitstreamUnit *units;
402
403 units = av_malloc_array(frag->nb_units + 1, sizeof(*units));
404 if (!units)
405 return AVERROR(ENOMEM);
406
407 if (position > 0)
408 memcpy(units, frag->units, position * sizeof(*units));
409 if (position < frag->nb_units)
410 memcpy(units + position + 1, frag->units + position,
411 (frag->nb_units - position) * sizeof(*units));
412
413 memset(units + position, 0, sizeof(*units));
414
415 av_freep(&frag->units);
416 frag->units = units;
417 ++frag->nb_units;
418
419 return 0;
420 }
421
422 int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx,
423 CodedBitstreamFragment *frag,
424 int position,
425 CodedBitstreamUnitType type,
426 void *content)
427 {
428 int err;
429
430 if (position == -1)
431 position = frag->nb_units;
432 av_assert0(position >= 0 && position <= frag->nb_units);
433
434 err = cbs_insert_unit(ctx, frag, position);
435 if (err < 0)
436 return err;
437
438 frag->units[position].type = type;
439 frag->units[position].content = content;
440 frag->units[position].content_external = 1;
441
442 return 0;
443 }
444
445 int ff_cbs_insert_unit_data(CodedBitstreamContext *ctx,
446 CodedBitstreamFragment *frag,
447 int position,
448 CodedBitstreamUnitType type,
449 uint8_t *data, size_t data_size)
450 {
451 int err;
452
453 if (position == -1)
454 position = frag->nb_units;
455 av_assert0(position >= 0 && position <= frag->nb_units);
456
457 err = cbs_insert_unit(ctx, frag, position);
458 if (err < 0)
459 return err;
460
461 frag->units[position].type = type;
462 frag->units[position].data = data;
463 frag->units[position].data_size = data_size;
464
465 return 0;
466 }
467
468 int ff_cbs_delete_unit(CodedBitstreamContext *ctx,
469 CodedBitstreamFragment *frag,
470 int position)
471 {
472 if (position < 0 || position >= frag->nb_units)
473 return AVERROR(EINVAL);
474
475 cbs_unit_uninit(ctx, &frag->units[position]);
476
477 --frag->nb_units;
478
479 if (frag->nb_units == 0) {
480 av_freep(&frag->units);
481
482 } else {
483 memmove(frag->units + position,
484 frag->units + position + 1,
485 (frag->nb_units - position) * sizeof(*frag->units));
486
487 // Don't bother reallocating the unit array.
488 }
489
490 return 0;
491 }