FFmpeg
cbs_h2645.c
Go to the documentation of this file.
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/attributes.h"
20 #include "libavutil/avassert.h"
21 
22 #include "bytestream.h"
23 #include "cbs.h"
24 #include "cbs_internal.h"
25 #include "cbs_h264.h"
26 #include "cbs_h265.h"
27 #include "h264.h"
28 #include "h264_sei.h"
29 #include "h2645_parse.h"
30 #include "hevc.h"
31 #include "hevc_sei.h"
32 
33 
35  const char *name, const int *subscripts,
36  uint32_t *write_to,
37  uint32_t range_min, uint32_t range_max)
38 {
39  uint32_t value;
40  int position, i, j;
41  unsigned int k;
42  char bits[65];
43 
44  position = get_bits_count(gbc);
45 
46  for (i = 0; i < 32; i++) {
47  if (get_bits_left(gbc) < i + 1) {
48  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid ue-golomb code at "
49  "%s: bitstream ended.\n", name);
50  return AVERROR_INVALIDDATA;
51  }
52  k = get_bits1(gbc);
53  bits[i] = k ? '1' : '0';
54  if (k)
55  break;
56  }
57  if (i >= 32) {
58  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid ue-golomb code at "
59  "%s: more than 31 zeroes.\n", name);
60  return AVERROR_INVALIDDATA;
61  }
62  value = 1;
63  for (j = 0; j < i; j++) {
64  k = get_bits1(gbc);
65  bits[i + j + 1] = k ? '1' : '0';
66  value = value << 1 | k;
67  }
68  bits[i + j + 1] = 0;
69  --value;
70 
71  if (ctx->trace_enable)
72  ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
73  bits, value);
74 
75  if (value < range_min || value > range_max) {
76  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
77  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
78  name, value, range_min, range_max);
79  return AVERROR_INVALIDDATA;
80  }
81 
82  *write_to = value;
83  return 0;
84 }
85 
87  const char *name, const int *subscripts,
88  int32_t *write_to,
89  int32_t range_min, int32_t range_max)
90 {
91  int32_t value;
92  int position, i, j;
93  unsigned int k;
94  uint32_t v;
95  char bits[65];
96 
97  position = get_bits_count(gbc);
98 
99  for (i = 0; i < 32; i++) {
100  if (get_bits_left(gbc) < i + 1) {
101  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at "
102  "%s: bitstream ended.\n", name);
103  return AVERROR_INVALIDDATA;
104  }
105  k = get_bits1(gbc);
106  bits[i] = k ? '1' : '0';
107  if (k)
108  break;
109  }
110  if (i >= 32) {
111  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at "
112  "%s: more than 31 zeroes.\n", name);
113  return AVERROR_INVALIDDATA;
114  }
115  v = 1;
116  for (j = 0; j < i; j++) {
117  k = get_bits1(gbc);
118  bits[i + j + 1] = k ? '1' : '0';
119  v = v << 1 | k;
120  }
121  bits[i + j + 1] = 0;
122  if (v & 1)
123  value = -(int32_t)(v / 2);
124  else
125  value = v / 2;
126 
127  if (ctx->trace_enable)
128  ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
129  bits, value);
130 
131  if (value < range_min || value > range_max) {
132  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
133  "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
134  name, value, range_min, range_max);
135  return AVERROR_INVALIDDATA;
136  }
137 
138  *write_to = value;
139  return 0;
140 }
141 
143  const char *name, const int *subscripts,
144  uint32_t value,
145  uint32_t range_min, uint32_t range_max)
146 {
147  int len;
148 
149  if (value < range_min || value > range_max) {
150  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
151  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
152  name, value, range_min, range_max);
153  return AVERROR_INVALIDDATA;
154  }
155  av_assert0(value != UINT32_MAX);
156 
157  len = av_log2(value + 1);
158  if (put_bits_left(pbc) < 2 * len + 1)
159  return AVERROR(ENOSPC);
160 
161  if (ctx->trace_enable) {
162  char bits[65];
163  int i;
164 
165  for (i = 0; i < len; i++)
166  bits[i] = '0';
167  bits[len] = '1';
168  for (i = 0; i < len; i++)
169  bits[len + i + 1] = (value + 1) >> (len - i - 1) & 1 ? '1' : '0';
170  bits[len + len + 1] = 0;
171 
173  name, subscripts, bits, value);
174  }
175 
176  put_bits(pbc, len, 0);
177  if (len + 1 < 32)
178  put_bits(pbc, len + 1, value + 1);
179  else
180  put_bits32(pbc, value + 1);
181 
182  return 0;
183 }
184 
186  const char *name, const int *subscripts,
187  int32_t value,
188  int32_t range_min, int32_t range_max)
189 {
190  int len;
191  uint32_t uvalue;
192 
193  if (value < range_min || value > range_max) {
194  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
195  "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
196  name, value, range_min, range_max);
197  return AVERROR_INVALIDDATA;
198  }
199  av_assert0(value != INT32_MIN);
200 
201  if (value == 0)
202  uvalue = 0;
203  else if (value > 0)
204  uvalue = 2 * (uint32_t)value - 1;
205  else
206  uvalue = 2 * (uint32_t)-value;
207 
208  len = av_log2(uvalue + 1);
209  if (put_bits_left(pbc) < 2 * len + 1)
210  return AVERROR(ENOSPC);
211 
212  if (ctx->trace_enable) {
213  char bits[65];
214  int i;
215 
216  for (i = 0; i < len; i++)
217  bits[i] = '0';
218  bits[len] = '1';
219  for (i = 0; i < len; i++)
220  bits[len + i + 1] = (uvalue + 1) >> (len - i - 1) & 1 ? '1' : '0';
221  bits[len + len + 1] = 0;
222 
224  name, subscripts, bits, value);
225  }
226 
227  put_bits(pbc, len, 0);
228  if (len + 1 < 32)
229  put_bits(pbc, len + 1, uvalue + 1);
230  else
231  put_bits32(pbc, uvalue + 1);
232 
233  return 0;
234 }
235 
236 #define HEADER(name) do { \
237  ff_cbs_trace_header(ctx, name); \
238  } while (0)
239 
240 #define CHECK(call) do { \
241  err = (call); \
242  if (err < 0) \
243  return err; \
244  } while (0)
245 
246 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
247 #define FUNC_H264(rw, name) FUNC_NAME(rw, h264, name)
248 #define FUNC_H265(rw, name) FUNC_NAME(rw, h265, name)
249 
250 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
251 
252 #define u(width, name, range_min, range_max) \
253  xu(width, name, current->name, range_min, range_max, 0)
254 #define ub(width, name) \
255  xu(width, name, current->name, 0, MAX_UINT_BITS(width), 0)
256 #define flag(name) ub(1, name)
257 #define ue(name, range_min, range_max) \
258  xue(name, current->name, range_min, range_max, 0)
259 #define i(width, name, range_min, range_max) \
260  xi(width, name, current->name, range_min, range_max, 0)
261 #define ib(width, name) \
262  xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0)
263 #define se(name, range_min, range_max) \
264  xse(name, current->name, range_min, range_max, 0)
265 
266 #define us(width, name, range_min, range_max, subs, ...) \
267  xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
268 #define ubs(width, name, subs, ...) \
269  xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
270 #define flags(name, subs, ...) \
271  xu(1, name, current->name, 0, 1, subs, __VA_ARGS__)
272 #define ues(name, range_min, range_max, subs, ...) \
273  xue(name, current->name, range_min, range_max, subs, __VA_ARGS__)
274 #define is(width, name, range_min, range_max, subs, ...) \
275  xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
276 #define ibs(width, name, subs, ...) \
277  xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__)
278 #define ses(name, range_min, range_max, subs, ...) \
279  xse(name, current->name, range_min, range_max, subs, __VA_ARGS__)
280 
281 #define fixed(width, name, value) do { \
282  av_unused uint32_t fixed_value = value; \
283  xu(width, name, fixed_value, value, value, 0); \
284  } while (0)
285 
286 
287 #define READ
288 #define READWRITE read
289 #define RWContext GetBitContext
290 
291 #define xu(width, name, var, range_min, range_max, subs, ...) do { \
292  uint32_t value; \
293  CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
294  SUBSCRIPTS(subs, __VA_ARGS__), \
295  &value, range_min, range_max)); \
296  var = value; \
297  } while (0)
298 #define xue(name, var, range_min, range_max, subs, ...) do { \
299  uint32_t value; \
300  CHECK(cbs_read_ue_golomb(ctx, rw, #name, \
301  SUBSCRIPTS(subs, __VA_ARGS__), \
302  &value, range_min, range_max)); \
303  var = value; \
304  } while (0)
305 #define xi(width, name, var, range_min, range_max, subs, ...) do { \
306  int32_t value; \
307  CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
308  SUBSCRIPTS(subs, __VA_ARGS__), \
309  &value, range_min, range_max)); \
310  var = value; \
311  } while (0)
312 #define xse(name, var, range_min, range_max, subs, ...) do { \
313  int32_t value; \
314  CHECK(cbs_read_se_golomb(ctx, rw, #name, \
315  SUBSCRIPTS(subs, __VA_ARGS__), \
316  &value, range_min, range_max)); \
317  var = value; \
318  } while (0)
319 
320 
321 #define infer(name, value) do { \
322  current->name = value; \
323  } while (0)
324 
326 {
327  int bits_left = get_bits_left(gbc);
328  if (bits_left > 8)
329  return 1;
330  if (bits_left == 0)
331  return 0;
332  if (show_bits(gbc, bits_left) & MAX_UINT_BITS(bits_left - 1))
333  return 1;
334  return 0;
335 }
336 
337 #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))
338 
339 #define byte_alignment(rw) (get_bits_count(rw) % 8)
340 
341 #define allocate(name, size) do { \
342  name ## _ref = av_buffer_allocz(size + \
343  AV_INPUT_BUFFER_PADDING_SIZE); \
344  if (!name ## _ref) \
345  return AVERROR(ENOMEM); \
346  name = name ## _ref->data; \
347  } while (0)
348 
349 #define FUNC(name) FUNC_H264(READWRITE, name)
351 #undef FUNC
352 
353 #define FUNC(name) FUNC_H265(READWRITE, name)
355 #undef FUNC
356 
357 #undef READ
358 #undef READWRITE
359 #undef RWContext
360 #undef xu
361 #undef xi
362 #undef xue
363 #undef xse
364 #undef infer
365 #undef more_rbsp_data
366 #undef byte_alignment
367 #undef allocate
368 
369 
370 #define WRITE
371 #define READWRITE write
372 #define RWContext PutBitContext
373 
374 #define xu(width, name, var, range_min, range_max, subs, ...) do { \
375  uint32_t value = var; \
376  CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
377  SUBSCRIPTS(subs, __VA_ARGS__), \
378  value, range_min, range_max)); \
379  } while (0)
380 #define xue(name, var, range_min, range_max, subs, ...) do { \
381  uint32_t value = var; \
382  CHECK(cbs_write_ue_golomb(ctx, rw, #name, \
383  SUBSCRIPTS(subs, __VA_ARGS__), \
384  value, range_min, range_max)); \
385  } while (0)
386 #define xi(width, name, var, range_min, range_max, subs, ...) do { \
387  int32_t value = var; \
388  CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
389  SUBSCRIPTS(subs, __VA_ARGS__), \
390  value, range_min, range_max)); \
391  } while (0)
392 #define xse(name, var, range_min, range_max, subs, ...) do { \
393  int32_t value = var; \
394  CHECK(cbs_write_se_golomb(ctx, rw, #name, \
395  SUBSCRIPTS(subs, __VA_ARGS__), \
396  value, range_min, range_max)); \
397  } while (0)
398 
399 #define infer(name, value) do { \
400  if (current->name != (value)) { \
401  av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
402  "%s does not match inferred value: " \
403  "%"PRId64", but should be %"PRId64".\n", \
404  #name, (int64_t)current->name, (int64_t)(value)); \
405  } \
406  } while (0)
407 
408 #define more_rbsp_data(var) (var)
409 
410 #define byte_alignment(rw) (put_bits_count(rw) % 8)
411 
412 #define allocate(name, size) do { \
413  if (!name) { \
414  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \
415  "for writing.\n", #name); \
416  return AVERROR_INVALIDDATA; \
417  } \
418  } while (0)
419 
420 #define FUNC(name) FUNC_H264(READWRITE, name)
422 #undef FUNC
423 
424 #define FUNC(name) FUNC_H265(READWRITE, name)
426 #undef FUNC
427 
428 #undef WRITE
429 #undef READWRITE
430 #undef RWContext
431 #undef xu
432 #undef xi
433 #undef xue
434 #undef xse
435 #undef u
436 #undef i
437 #undef flag
438 #undef ue
439 #undef se
440 #undef infer
441 #undef more_rbsp_data
442 #undef byte_alignment
443 #undef allocate
444 
445 
446 static void cbs_h264_free_pps(void *opaque, uint8_t *content)
447 {
448  H264RawPPS *pps = (H264RawPPS*)content;
450  av_freep(&content);
451 }
452 
454 {
455  switch (payload->payload_type) {
463  break;
466  break;
469  break;
470  default:
471  av_buffer_unref(&payload->payload.other.data_ref);
472  break;
473  }
474 }
475 
476 static void cbs_h264_free_sei(void *opaque, uint8_t *content)
477 {
478  H264RawSEI *sei = (H264RawSEI*)content;
479  int i;
480  for (i = 0; i < sei->payload_count; i++)
482  av_freep(&content);
483 }
484 
485 static void cbs_h264_free_slice(void *opaque, uint8_t *content)
486 {
487  H264RawSlice *slice = (H264RawSlice*)content;
488  av_buffer_unref(&slice->data_ref);
489  av_freep(&content);
490 }
491 
492 static void cbs_h265_free_vps(void *opaque, uint8_t *content)
493 {
494  H265RawVPS *vps = (H265RawVPS*)content;
496  av_freep(&content);
497 }
498 
499 static void cbs_h265_free_sps(void *opaque, uint8_t *content)
500 {
501  H265RawSPS *sps = (H265RawSPS*)content;
503  av_freep(&content);
504 }
505 
506 static void cbs_h265_free_pps(void *opaque, uint8_t *content)
507 {
508  H265RawPPS *pps = (H265RawPPS*)content;
510  av_freep(&content);
511 }
512 
513 static void cbs_h265_free_slice(void *opaque, uint8_t *content)
514 {
515  H265RawSlice *slice = (H265RawSlice*)content;
516  av_buffer_unref(&slice->data_ref);
517  av_freep(&content);
518 }
519 
521 {
522  switch (payload->payload_type) {
535  break;
538  break;
541  break;
542  default:
543  av_buffer_unref(&payload->payload.other.data_ref);
544  break;
545  }
546 }
547 
548 static void cbs_h265_free_sei(void *opaque, uint8_t *content)
549 {
550  H265RawSEI *sei = (H265RawSEI*)content;
551  int i;
552  for (i = 0; i < sei->payload_count; i++)
554  av_freep(&content);
555 }
556 
559  const H2645Packet *packet)
560 {
561  int err, i;
562 
563  for (i = 0; i < packet->nb_nals; i++) {
564  const H2645NAL *nal = &packet->nals[i];
565  AVBufferRef *ref;
566  size_t size = nal->size;
567 
568  if (nal->nuh_layer_id > 0)
569  continue;
570 
571  // Remove trailing zeroes.
572  while (size > 0 && nal->data[size - 1] == 0)
573  --size;
574  if (size == 0) {
575  av_log(ctx->log_ctx, AV_LOG_VERBOSE, "Discarding empty 0 NAL unit\n");
576  continue;
577  }
578 
579  ref = (nal->data == nal->raw_data) ? frag->data_ref
580  : packet->rbsp.rbsp_buffer_ref;
581 
582  err = ff_cbs_insert_unit_data(ctx, frag, -1, nal->type,
583  (uint8_t*)nal->data, size, ref);
584  if (err < 0)
585  return err;
586  }
587 
588  return 0;
589 }
590 
593  int header)
594 {
595  enum AVCodecID codec_id = ctx->codec->codec_id;
597  GetByteContext gbc;
598  int err;
599 
600  av_assert0(frag->data && frag->nb_units == 0);
601  if (frag->data_size == 0)
602  return 0;
603 
604  if (header && frag->data[0] && codec_id == AV_CODEC_ID_H264) {
605  // AVCC header.
606  size_t size, start, end;
607  int i, count, version;
608 
609  priv->mp4 = 1;
610 
611  bytestream2_init(&gbc, frag->data, frag->data_size);
612 
613  if (bytestream2_get_bytes_left(&gbc) < 6)
614  return AVERROR_INVALIDDATA;
615 
616  version = bytestream2_get_byte(&gbc);
617  if (version != 1) {
618  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid AVCC header: "
619  "first byte %u.", version);
620  return AVERROR_INVALIDDATA;
621  }
622 
623  bytestream2_skip(&gbc, 3);
624  priv->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;
625 
626  // SPS array.
627  count = bytestream2_get_byte(&gbc) & 0x1f;
628  start = bytestream2_tell(&gbc);
629  for (i = 0; i < count; i++) {
630  if (bytestream2_get_bytes_left(&gbc) < 2 * (count - i))
631  return AVERROR_INVALIDDATA;
632  size = bytestream2_get_be16(&gbc);
633  if (bytestream2_get_bytes_left(&gbc) < size)
634  return AVERROR_INVALIDDATA;
635  bytestream2_skip(&gbc, size);
636  }
637  end = bytestream2_tell(&gbc);
638 
639  err = ff_h2645_packet_split(&priv->read_packet,
640  frag->data + start, end - start,
641  ctx->log_ctx, 1, 2, AV_CODEC_ID_H264, 1, 1);
642  if (err < 0) {
643  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC SPS array.\n");
644  return err;
645  }
646  err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);
647  if (err < 0)
648  return err;
649 
650  // PPS array.
651  count = bytestream2_get_byte(&gbc);
652  start = bytestream2_tell(&gbc);
653  for (i = 0; i < count; i++) {
654  if (bytestream2_get_bytes_left(&gbc) < 2 * (count - i))
655  return AVERROR_INVALIDDATA;
656  size = bytestream2_get_be16(&gbc);
657  if (bytestream2_get_bytes_left(&gbc) < size)
658  return AVERROR_INVALIDDATA;
659  bytestream2_skip(&gbc, size);
660  }
661  end = bytestream2_tell(&gbc);
662 
663  err = ff_h2645_packet_split(&priv->read_packet,
664  frag->data + start, end - start,
665  ctx->log_ctx, 1, 2, AV_CODEC_ID_H264, 1, 1);
666  if (err < 0) {
667  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC PPS array.\n");
668  return err;
669  }
670  err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);
671  if (err < 0)
672  return err;
673 
674  if (bytestream2_get_bytes_left(&gbc) > 0) {
675  av_log(ctx->log_ctx, AV_LOG_WARNING, "%u bytes left at end of AVCC "
676  "header.\n", bytestream2_get_bytes_left(&gbc));
677  }
678 
679  } else if (header && frag->data[0] && codec_id == AV_CODEC_ID_HEVC) {
680  // HVCC header.
681  size_t size, start, end;
682  int i, j, nb_arrays, nal_unit_type, nb_nals, version;
683 
684  priv->mp4 = 1;
685 
686  bytestream2_init(&gbc, frag->data, frag->data_size);
687 
688  if (bytestream2_get_bytes_left(&gbc) < 23)
689  return AVERROR_INVALIDDATA;
690 
691  version = bytestream2_get_byte(&gbc);
692  if (version != 1) {
693  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid HVCC header: "
694  "first byte %u.", version);
695  return AVERROR_INVALIDDATA;
696  }
697 
698  bytestream2_skip(&gbc, 20);
699  priv->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;
700 
701  nb_arrays = bytestream2_get_byte(&gbc);
702  for (i = 0; i < nb_arrays; i++) {
703  nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;
704  nb_nals = bytestream2_get_be16(&gbc);
705 
706  start = bytestream2_tell(&gbc);
707  for (j = 0; j < nb_nals; j++) {
708  if (bytestream2_get_bytes_left(&gbc) < 2)
709  return AVERROR_INVALIDDATA;
710  size = bytestream2_get_be16(&gbc);
711  if (bytestream2_get_bytes_left(&gbc) < size)
712  return AVERROR_INVALIDDATA;
713  bytestream2_skip(&gbc, size);
714  }
715  end = bytestream2_tell(&gbc);
716 
717  err = ff_h2645_packet_split(&priv->read_packet,
718  frag->data + start, end - start,
719  ctx->log_ctx, 1, 2, AV_CODEC_ID_HEVC, 1, 1);
720  if (err < 0) {
721  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split "
722  "HVCC array %d (%d NAL units of type %d).\n",
723  i, nb_nals, nal_unit_type);
724  return err;
725  }
726  err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);
727  if (err < 0)
728  return err;
729  }
730 
731  } else {
732  // Annex B, or later MP4 with already-known parameters.
733 
734  err = ff_h2645_packet_split(&priv->read_packet,
735  frag->data, frag->data_size,
736  ctx->log_ctx,
737  priv->mp4, priv->nal_length_size,
738  codec_id, 1, 1);
739  if (err < 0)
740  return err;
741 
742  err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);
743  if (err < 0)
744  return err;
745  }
746 
747  return 0;
748 }
749 
750 #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \
751 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
752  CodedBitstreamUnit *unit) \
753 { \
754  CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
755  H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \
756  unsigned int id = ps_var->id_element; \
757  if (id >= FF_ARRAY_ELEMS(priv->ps_var)) { \
758  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid " #ps_name \
759  " id : %d.\n", id); \
760  return AVERROR_INVALIDDATA; \
761  } \
762  if (priv->ps_var[id] == priv->active_ ## ps_var) \
763  priv->active_ ## ps_var = NULL ; \
764  av_buffer_unref(&priv->ps_var ## _ref[id]); \
765  if (unit->content_ref) \
766  priv->ps_var ## _ref[id] = av_buffer_ref(unit->content_ref); \
767  else \
768  priv->ps_var ## _ref[id] = av_buffer_alloc(sizeof(*ps_var)); \
769  if (!priv->ps_var ## _ref[id]) \
770  return AVERROR(ENOMEM); \
771  priv->ps_var[id] = (H26 ## h26n ## Raw ## ps_name *)priv->ps_var ## _ref[id]->data; \
772  if (!unit->content_ref) \
773  memcpy(priv->ps_var[id], ps_var, sizeof(*ps_var)); \
774  return 0; \
775 }
776 
777 cbs_h2645_replace_ps(4, SPS, sps, seq_parameter_set_id)
778 cbs_h2645_replace_ps(4, PPS, pps, pic_parameter_set_id)
779 cbs_h2645_replace_ps(5, VPS, vps, vps_video_parameter_set_id)
780 cbs_h2645_replace_ps(5, SPS, sps, sps_seq_parameter_set_id)
781 cbs_h2645_replace_ps(5, PPS, pps, pps_pic_parameter_set_id)
782 
783 static int cbs_h264_read_nal_unit(CodedBitstreamContext *ctx,
784  CodedBitstreamUnit *unit)
785 {
786  GetBitContext gbc;
787  int err;
788 
789  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
790  if (err < 0)
791  return err;
792 
793  switch (unit->type) {
794  case H264_NAL_SPS:
795  {
796  H264RawSPS *sps;
797 
798  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*sps), NULL);
799  if (err < 0)
800  return err;
801  sps = unit->content;
802 
803  err = cbs_h264_read_sps(ctx, &gbc, sps);
804  if (err < 0)
805  return err;
806 
807  err = cbs_h264_replace_sps(ctx, unit);
808  if (err < 0)
809  return err;
810  }
811  break;
812 
813  case H264_NAL_SPS_EXT:
814  {
815  err = ff_cbs_alloc_unit_content(ctx, unit,
816  sizeof(H264RawSPSExtension),
817  NULL);
818  if (err < 0)
819  return err;
820 
821  err = cbs_h264_read_sps_extension(ctx, &gbc, unit->content);
822  if (err < 0)
823  return err;
824  }
825  break;
826 
827  case H264_NAL_PPS:
828  {
829  H264RawPPS *pps;
830 
831  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),
833  if (err < 0)
834  return err;
835  pps = unit->content;
836 
837  err = cbs_h264_read_pps(ctx, &gbc, pps);
838  if (err < 0)
839  return err;
840 
841  err = cbs_h264_replace_pps(ctx, unit);
842  if (err < 0)
843  return err;
844  }
845  break;
846 
847  case H264_NAL_SLICE:
848  case H264_NAL_IDR_SLICE:
850  {
851  H264RawSlice *slice;
852  int pos, len;
853 
854  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),
856  if (err < 0)
857  return err;
858  slice = unit->content;
859 
860  err = cbs_h264_read_slice_header(ctx, &gbc, &slice->header);
861  if (err < 0)
862  return err;
863 
864  pos = get_bits_count(&gbc);
865  len = unit->data_size;
866  if (!unit->data[len - 1]) {
867  int z;
868  for (z = 0; z < len && !unit->data[len - z - 1]; z++);
869  av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
870  "from slice data.\n", z);
871  len -= z;
872  }
873 
874  slice->data_size = len - pos / 8;
875  slice->data_ref = av_buffer_ref(unit->data_ref);
876  if (!slice->data_ref)
877  return AVERROR(ENOMEM);
878  slice->data = unit->data + pos / 8;
879  slice->data_bit_start = pos % 8;
880  }
881  break;
882 
883  case H264_NAL_AUD:
884  {
885  err = ff_cbs_alloc_unit_content(ctx, unit,
886  sizeof(H264RawAUD), NULL);
887  if (err < 0)
888  return err;
889 
890  err = cbs_h264_read_aud(ctx, &gbc, unit->content);
891  if (err < 0)
892  return err;
893  }
894  break;
895 
896  case H264_NAL_SEI:
897  {
898  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(H264RawSEI),
900  if (err < 0)
901  return err;
902 
903  err = cbs_h264_read_sei(ctx, &gbc, unit->content);
904  if (err < 0)
905  return err;
906  }
907  break;
908 
910  {
911  err = ff_cbs_alloc_unit_content(ctx, unit,
912  sizeof(H264RawFiller), NULL);
913  if (err < 0)
914  return err;
915 
916  err = cbs_h264_read_filler(ctx, &gbc, unit->content);
917  if (err < 0)
918  return err;
919  }
920  break;
921 
923  case H264_NAL_END_STREAM:
924  {
925  err = ff_cbs_alloc_unit_content(ctx, unit,
926  sizeof(H264RawNALUnitHeader),
927  NULL);
928  if (err < 0)
929  return err;
930 
931  err = (unit->type == H264_NAL_END_SEQUENCE ?
932  cbs_h264_read_end_of_sequence :
933  cbs_h264_read_end_of_stream)(ctx, &gbc, unit->content);
934  if (err < 0)
935  return err;
936  }
937  break;
938 
939  default:
940  return AVERROR(ENOSYS);
941  }
942 
943  return 0;
944 }
945 
947  CodedBitstreamUnit *unit)
948 {
949  GetBitContext gbc;
950  int err;
951 
952  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
953  if (err < 0)
954  return err;
955 
956  switch (unit->type) {
957  case HEVC_NAL_VPS:
958  {
959  H265RawVPS *vps;
960 
961  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*vps),
963  if (err < 0)
964  return err;
965  vps = unit->content;
966 
967  err = cbs_h265_read_vps(ctx, &gbc, vps);
968  if (err < 0)
969  return err;
970 
971  err = cbs_h265_replace_vps(ctx, unit);
972  if (err < 0)
973  return err;
974  }
975  break;
976  case HEVC_NAL_SPS:
977  {
978  H265RawSPS *sps;
979 
980  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*sps),
982  if (err < 0)
983  return err;
984  sps = unit->content;
985 
986  err = cbs_h265_read_sps(ctx, &gbc, sps);
987  if (err < 0)
988  return err;
989 
990  err = cbs_h265_replace_sps(ctx, unit);
991  if (err < 0)
992  return err;
993  }
994  break;
995 
996  case HEVC_NAL_PPS:
997  {
998  H265RawPPS *pps;
999 
1000  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),
1002  if (err < 0)
1003  return err;
1004  pps = unit->content;
1005 
1006  err = cbs_h265_read_pps(ctx, &gbc, pps);
1007  if (err < 0)
1008  return err;
1009 
1010  err = cbs_h265_replace_pps(ctx, unit);
1011  if (err < 0)
1012  return err;
1013  }
1014  break;
1015 
1016  case HEVC_NAL_TRAIL_N:
1017  case HEVC_NAL_TRAIL_R:
1018  case HEVC_NAL_TSA_N:
1019  case HEVC_NAL_TSA_R:
1020  case HEVC_NAL_STSA_N:
1021  case HEVC_NAL_STSA_R:
1022  case HEVC_NAL_RADL_N:
1023  case HEVC_NAL_RADL_R:
1024  case HEVC_NAL_RASL_N:
1025  case HEVC_NAL_RASL_R:
1026  case HEVC_NAL_BLA_W_LP:
1027  case HEVC_NAL_BLA_W_RADL:
1028  case HEVC_NAL_BLA_N_LP:
1029  case HEVC_NAL_IDR_W_RADL:
1030  case HEVC_NAL_IDR_N_LP:
1031  case HEVC_NAL_CRA_NUT:
1032  {
1033  H265RawSlice *slice;
1034  int pos, len;
1035 
1036  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),
1038  if (err < 0)
1039  return err;
1040  slice = unit->content;
1041 
1042  err = cbs_h265_read_slice_segment_header(ctx, &gbc, &slice->header);
1043  if (err < 0)
1044  return err;
1045 
1046  pos = get_bits_count(&gbc);
1047  len = unit->data_size;
1048  if (!unit->data[len - 1]) {
1049  int z;
1050  for (z = 0; z < len && !unit->data[len - z - 1]; z++);
1051  av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
1052  "from slice data.\n", z);
1053  len -= z;
1054  }
1055 
1056  slice->data_size = len - pos / 8;
1057  slice->data_ref = av_buffer_ref(unit->data_ref);
1058  if (!slice->data_ref)
1059  return AVERROR(ENOMEM);
1060  slice->data = unit->data + pos / 8;
1061  slice->data_bit_start = pos % 8;
1062  }
1063  break;
1064 
1065  case HEVC_NAL_AUD:
1066  {
1067  err = ff_cbs_alloc_unit_content(ctx, unit,
1068  sizeof(H265RawAUD), NULL);
1069  if (err < 0)
1070  return err;
1071 
1072  err = cbs_h265_read_aud(ctx, &gbc, unit->content);
1073  if (err < 0)
1074  return err;
1075  }
1076  break;
1077 
1078  case HEVC_NAL_SEI_PREFIX:
1079  case HEVC_NAL_SEI_SUFFIX:
1080  {
1081  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(H265RawSEI),
1083 
1084  if (err < 0)
1085  return err;
1086 
1087  err = cbs_h265_read_sei(ctx, &gbc, unit->content,
1088  unit->type == HEVC_NAL_SEI_PREFIX);
1089 
1090  if (err < 0)
1091  return err;
1092  }
1093  break;
1094 
1095  default:
1096  return AVERROR(ENOSYS);
1097  }
1098 
1099  return 0;
1100 }
1101 
1103  PutBitContext *pbc, const uint8_t *data,
1104  size_t data_size, int data_bit_start)
1105 {
1106  size_t rest = data_size - (data_bit_start + 7) / 8;
1107  const uint8_t *pos = data + data_bit_start / 8;
1108 
1109  av_assert0(data_bit_start >= 0 &&
1110  data_size > data_bit_start / 8);
1111 
1112  if (data_size * 8 + 8 > put_bits_left(pbc))
1113  return AVERROR(ENOSPC);
1114 
1115  if (!rest)
1116  goto rbsp_stop_one_bit;
1117 
1118  // First copy the remaining bits of the first byte
1119  // The above check ensures that we do not accidentally
1120  // copy beyond the rbsp_stop_one_bit.
1121  if (data_bit_start % 8)
1122  put_bits(pbc, 8 - data_bit_start % 8,
1123  *pos++ & MAX_UINT_BITS(8 - data_bit_start % 8));
1124 
1125  if (put_bits_count(pbc) % 8 == 0) {
1126  // If the writer is aligned at this point,
1127  // memcpy can be used to improve performance.
1128  // This happens normally for CABAC.
1129  flush_put_bits(pbc);
1130  memcpy(put_bits_ptr(pbc), pos, rest);
1131  skip_put_bytes(pbc, rest);
1132  } else {
1133  // If not, we have to copy manually.
1134  // rbsp_stop_one_bit forces us to special-case
1135  // the last byte.
1136  uint8_t temp;
1137  int i;
1138 
1139  for (; rest > 4; rest -= 4, pos += 4)
1140  put_bits32(pbc, AV_RB32(pos));
1141 
1142  for (; rest > 1; rest--, pos++)
1143  put_bits(pbc, 8, *pos);
1144 
1145  rbsp_stop_one_bit:
1146  temp = rest ? *pos : *pos & MAX_UINT_BITS(8 - data_bit_start % 8);
1147 
1148  av_assert0(temp);
1149  i = ff_ctz(*pos);
1150  temp = temp >> i;
1151  i = rest ? (8 - i) : (8 - i - data_bit_start % 8);
1152  put_bits(pbc, i, temp);
1153  if (put_bits_count(pbc) % 8)
1154  put_bits(pbc, 8 - put_bits_count(pbc) % 8, 0);
1155  }
1156 
1157  return 0;
1158 }
1159 
1161  CodedBitstreamUnit *unit,
1162  PutBitContext *pbc)
1163 {
1164  int err;
1165 
1166  switch (unit->type) {
1167  case H264_NAL_SPS:
1168  {
1169  H264RawSPS *sps = unit->content;
1170 
1171  err = cbs_h264_write_sps(ctx, pbc, sps);
1172  if (err < 0)
1173  return err;
1174 
1175  err = cbs_h264_replace_sps(ctx, unit);
1176  if (err < 0)
1177  return err;
1178  }
1179  break;
1180 
1181  case H264_NAL_SPS_EXT:
1182  {
1183  H264RawSPSExtension *sps_ext = unit->content;
1184 
1185  err = cbs_h264_write_sps_extension(ctx, pbc, sps_ext);
1186  if (err < 0)
1187  return err;
1188  }
1189  break;
1190 
1191  case H264_NAL_PPS:
1192  {
1193  H264RawPPS *pps = unit->content;
1194 
1195  err = cbs_h264_write_pps(ctx, pbc, pps);
1196  if (err < 0)
1197  return err;
1198 
1199  err = cbs_h264_replace_pps(ctx, unit);
1200  if (err < 0)
1201  return err;
1202  }
1203  break;
1204 
1205  case H264_NAL_SLICE:
1206  case H264_NAL_IDR_SLICE:
1208  {
1209  H264RawSlice *slice = unit->content;
1210 
1211  err = cbs_h264_write_slice_header(ctx, pbc, &slice->header);
1212  if (err < 0)
1213  return err;
1214 
1215  if (slice->data) {
1216  err = cbs_h2645_write_slice_data(ctx, pbc, slice->data,
1217  slice->data_size,
1218  slice->data_bit_start);
1219  if (err < 0)
1220  return err;
1221  } else {
1222  // No slice data - that was just the header.
1223  // (Bitstream may be unaligned!)
1224  }
1225  }
1226  break;
1227 
1228  case H264_NAL_AUD:
1229  {
1230  err = cbs_h264_write_aud(ctx, pbc, unit->content);
1231  if (err < 0)
1232  return err;
1233  }
1234  break;
1235 
1236  case H264_NAL_SEI:
1237  {
1238  err = cbs_h264_write_sei(ctx, pbc, unit->content);
1239  if (err < 0)
1240  return err;
1241  }
1242  break;
1243 
1244  case H264_NAL_FILLER_DATA:
1245  {
1246  err = cbs_h264_write_filler(ctx, pbc, unit->content);
1247  if (err < 0)
1248  return err;
1249  }
1250  break;
1251 
1252  case H264_NAL_END_SEQUENCE:
1253  {
1254  err = cbs_h264_write_end_of_sequence(ctx, pbc, unit->content);
1255  if (err < 0)
1256  return err;
1257  }
1258  break;
1259 
1260  case H264_NAL_END_STREAM:
1261  {
1262  err = cbs_h264_write_end_of_stream(ctx, pbc, unit->content);
1263  if (err < 0)
1264  return err;
1265  }
1266  break;
1267 
1268  default:
1269  av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for "
1270  "NAL unit type %"PRIu32".\n", unit->type);
1271  return AVERROR_PATCHWELCOME;
1272  }
1273 
1274  return 0;
1275 }
1276 
1278  CodedBitstreamUnit *unit,
1279  PutBitContext *pbc)
1280 {
1281  int err;
1282 
1283  switch (unit->type) {
1284  case HEVC_NAL_VPS:
1285  {
1286  H265RawVPS *vps = unit->content;
1287 
1288  err = cbs_h265_write_vps(ctx, pbc, vps);
1289  if (err < 0)
1290  return err;
1291 
1292  err = cbs_h265_replace_vps(ctx, unit);
1293  if (err < 0)
1294  return err;
1295  }
1296  break;
1297 
1298  case HEVC_NAL_SPS:
1299  {
1300  H265RawSPS *sps = unit->content;
1301 
1302  err = cbs_h265_write_sps(ctx, pbc, sps);
1303  if (err < 0)
1304  return err;
1305 
1306  err = cbs_h265_replace_sps(ctx, unit);
1307  if (err < 0)
1308  return err;
1309  }
1310  break;
1311 
1312  case HEVC_NAL_PPS:
1313  {
1314  H265RawPPS *pps = unit->content;
1315 
1316  err = cbs_h265_write_pps(ctx, pbc, pps);
1317  if (err < 0)
1318  return err;
1319 
1320  err = cbs_h265_replace_pps(ctx, unit);
1321  if (err < 0)
1322  return err;
1323  }
1324  break;
1325 
1326  case HEVC_NAL_TRAIL_N:
1327  case HEVC_NAL_TRAIL_R:
1328  case HEVC_NAL_TSA_N:
1329  case HEVC_NAL_TSA_R:
1330  case HEVC_NAL_STSA_N:
1331  case HEVC_NAL_STSA_R:
1332  case HEVC_NAL_RADL_N:
1333  case HEVC_NAL_RADL_R:
1334  case HEVC_NAL_RASL_N:
1335  case HEVC_NAL_RASL_R:
1336  case HEVC_NAL_BLA_W_LP:
1337  case HEVC_NAL_BLA_W_RADL:
1338  case HEVC_NAL_BLA_N_LP:
1339  case HEVC_NAL_IDR_W_RADL:
1340  case HEVC_NAL_IDR_N_LP:
1341  case HEVC_NAL_CRA_NUT:
1342  {
1343  H265RawSlice *slice = unit->content;
1344 
1345  err = cbs_h265_write_slice_segment_header(ctx, pbc, &slice->header);
1346  if (err < 0)
1347  return err;
1348 
1349  if (slice->data) {
1350  err = cbs_h2645_write_slice_data(ctx, pbc, slice->data,
1351  slice->data_size,
1352  slice->data_bit_start);
1353  if (err < 0)
1354  return err;
1355  } else {
1356  // No slice data - that was just the header.
1357  }
1358  }
1359  break;
1360 
1361  case HEVC_NAL_AUD:
1362  {
1363  err = cbs_h265_write_aud(ctx, pbc, unit->content);
1364  if (err < 0)
1365  return err;
1366  }
1367  break;
1368 
1369  case HEVC_NAL_SEI_PREFIX:
1370  case HEVC_NAL_SEI_SUFFIX:
1371  {
1372  err = cbs_h265_write_sei(ctx, pbc, unit->content,
1373  unit->type == HEVC_NAL_SEI_PREFIX);
1374 
1375  if (err < 0)
1376  return err;
1377  }
1378  break;
1379 
1380  default:
1381  av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for "
1382  "NAL unit type %"PRIu32".\n", unit->type);
1383  return AVERROR_PATCHWELCOME;
1384  }
1385 
1386  return 0;
1387 }
1388 
1390  CodedBitstreamFragment *frag)
1391 {
1392  uint8_t *data;
1393  size_t max_size, dp, sp;
1394  int err, i, zero_run;
1395 
1396  for (i = 0; i < frag->nb_units; i++) {
1397  // Data should already all have been written when we get here.
1398  av_assert0(frag->units[i].data);
1399  }
1400 
1401  max_size = 0;
1402  for (i = 0; i < frag->nb_units; i++) {
1403  // Start code + content with worst-case emulation prevention.
1404  max_size += 4 + frag->units[i].data_size * 3 / 2;
1405  }
1406 
1407  data = av_realloc(NULL, max_size + AV_INPUT_BUFFER_PADDING_SIZE);
1408  if (!data)
1409  return AVERROR(ENOMEM);
1410 
1411  dp = 0;
1412  for (i = 0; i < frag->nb_units; i++) {
1413  CodedBitstreamUnit *unit = &frag->units[i];
1414 
1415  if (unit->data_bit_padding > 0) {
1416  if (i < frag->nb_units - 1)
1417  av_log(ctx->log_ctx, AV_LOG_WARNING, "Probably invalid "
1418  "unaligned padding on non-final NAL unit.\n");
1419  else
1420  frag->data_bit_padding = unit->data_bit_padding;
1421  }
1422 
1423  if ((ctx->codec->codec_id == AV_CODEC_ID_H264 &&
1424  (unit->type == H264_NAL_SPS ||
1425  unit->type == H264_NAL_PPS)) ||
1426  (ctx->codec->codec_id == AV_CODEC_ID_HEVC &&
1427  (unit->type == HEVC_NAL_VPS ||
1428  unit->type == HEVC_NAL_SPS ||
1429  unit->type == HEVC_NAL_PPS)) ||
1430  i == 0 /* (Assume this is the start of an access unit.) */) {
1431  // zero_byte
1432  data[dp++] = 0;
1433  }
1434  // start_code_prefix_one_3bytes
1435  data[dp++] = 0;
1436  data[dp++] = 0;
1437  data[dp++] = 1;
1438 
1439  zero_run = 0;
1440  for (sp = 0; sp < unit->data_size; sp++) {
1441  if (zero_run < 2) {
1442  if (unit->data[sp] == 0)
1443  ++zero_run;
1444  else
1445  zero_run = 0;
1446  } else {
1447  if ((unit->data[sp] & ~3) == 0) {
1448  // emulation_prevention_three_byte
1449  data[dp++] = 3;
1450  }
1451  zero_run = unit->data[sp] == 0;
1452  }
1453  data[dp++] = unit->data[sp];
1454  }
1455  }
1456 
1457  av_assert0(dp <= max_size);
1458  err = av_reallocp(&data, dp + AV_INPUT_BUFFER_PADDING_SIZE);
1459  if (err)
1460  return err;
1461  memset(data + dp, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1462 
1464  NULL, NULL, 0);
1465  if (!frag->data_ref) {
1466  av_freep(&data);
1467  return AVERROR(ENOMEM);
1468  }
1469 
1470  frag->data = data;
1471  frag->data_size = dp;
1472 
1473  return 0;
1474 }
1475 
1477 {
1478  CodedBitstreamH264Context *h264 = ctx->priv_data;
1479  int i;
1480 
1482 
1483  for (i = 0; i < FF_ARRAY_ELEMS(h264->sps); i++)
1484  av_buffer_unref(&h264->sps_ref[i]);
1485  for (i = 0; i < FF_ARRAY_ELEMS(h264->pps); i++)
1486  av_buffer_unref(&h264->pps_ref[i]);
1487 }
1488 
1490 {
1491  CodedBitstreamH265Context *h265 = ctx->priv_data;
1492  int i;
1493 
1495 
1496  for (i = 0; i < FF_ARRAY_ELEMS(h265->vps); i++)
1497  av_buffer_unref(&h265->vps_ref[i]);
1498  for (i = 0; i < FF_ARRAY_ELEMS(h265->sps); i++)
1499  av_buffer_unref(&h265->sps_ref[i]);
1500  for (i = 0; i < FF_ARRAY_ELEMS(h265->pps); i++)
1501  av_buffer_unref(&h265->pps_ref[i]);
1502 }
1503 
1506 
1507  .priv_data_size = sizeof(CodedBitstreamH264Context),
1508 
1509  .split_fragment = &cbs_h2645_split_fragment,
1510  .read_unit = &cbs_h264_read_nal_unit,
1511  .write_unit = &cbs_h264_write_nal_unit,
1512  .assemble_fragment = &cbs_h2645_assemble_fragment,
1513 
1514  .close = &cbs_h264_close,
1515 };
1516 
1519 
1520  .priv_data_size = sizeof(CodedBitstreamH265Context),
1521 
1522  .split_fragment = &cbs_h2645_split_fragment,
1523  .read_unit = &cbs_h265_read_nal_unit,
1524  .write_unit = &cbs_h265_write_nal_unit,
1525  .assemble_fragment = &cbs_h2645_assemble_fragment,
1526 
1527  .close = &cbs_h265_close,
1528 };
1529 
1532  H264RawSEIPayload *payload)
1533 {
1534  H264RawSEI *sei = NULL;
1535  int err, i;
1536 
1537  // Find an existing SEI NAL unit to add to.
1538  for (i = 0; i < au->nb_units; i++) {
1539  if (au->units[i].type == H264_NAL_SEI) {
1540  sei = au->units[i].content;
1542  break;
1543 
1544  sei = NULL;
1545  }
1546  }
1547 
1548  if (!sei) {
1549  // Need to make a new SEI NAL unit. Insert it before the first
1550  // slice data NAL unit; if no slice data, add at the end.
1551  AVBufferRef *sei_ref;
1552 
1553  sei = av_mallocz(sizeof(*sei));
1554  if (!sei) {
1555  err = AVERROR(ENOMEM);
1556  goto fail;
1557  }
1558 
1560  sei->nal_unit_header.nal_ref_idc = 0;
1561 
1562  sei_ref = av_buffer_create((uint8_t*)sei, sizeof(*sei),
1563  &cbs_h264_free_sei, NULL, 0);
1564  if (!sei_ref) {
1565  av_freep(&sei);
1566  err = AVERROR(ENOMEM);
1567  goto fail;
1568  }
1569 
1570  for (i = 0; i < au->nb_units; i++) {
1571  if (au->units[i].type == H264_NAL_SLICE ||
1572  au->units[i].type == H264_NAL_IDR_SLICE)
1573  break;
1574  }
1575 
1576  err = ff_cbs_insert_unit_content(ctx, au, i, H264_NAL_SEI,
1577  sei, sei_ref);
1578  av_buffer_unref(&sei_ref);
1579  if (err < 0)
1580  goto fail;
1581  }
1582 
1583  memcpy(&sei->payload[sei->payload_count], payload, sizeof(*payload));
1584  ++sei->payload_count;
1585 
1586  return 0;
1587 fail:
1588  cbs_h264_free_sei_payload(payload);
1589  return err;
1590 }
1591 
1594  CodedBitstreamUnit *nal,
1595  int position)
1596 {
1597  H264RawSEI *sei = nal->content;
1598 
1599  av_assert0(nal->type == H264_NAL_SEI);
1600  av_assert0(position >= 0 && position < sei->payload_count);
1601 
1602  if (position == 0 && sei->payload_count == 1) {
1603  // Deleting NAL unit entirely.
1604  int i;
1605 
1606  for (i = 0; i < au->nb_units; i++) {
1607  if (&au->units[i] == nal)
1608  break;
1609  }
1610 
1611  ff_cbs_delete_unit(ctx, au, i);
1612  } else {
1613  cbs_h264_free_sei_payload(&sei->payload[position]);
1614 
1615  --sei->payload_count;
1616  memmove(sei->payload + position,
1617  sei->payload + position + 1,
1618  (sei->payload_count - position) * sizeof(*sei->payload));
1619  }
1620 }
uint32_t payload_type
Definition: cbs_h264.h:322
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:250
#define NULL
Definition: coverity.c:32
struct H265RawSEIPayload::@56::@57 other
#define ff_ctz
Definition: intmath.h:106
int nb_units
Number of units in this fragment.
Definition: cbs.h:147
H265RawPPS * pps[HEVC_MAX_PPS_COUNT]
Definition: cbs_h265.h:738
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
H265RawSEIUserDataUnregistered user_data_unregistered
Definition: cbs_h265.h:701
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:126
static int cbs_h2645_write_slice_data(CodedBitstreamContext *ctx, PutBitContext *pbc, const uint8_t *data, size_t data_size, int data_bit_start)
Definition: cbs_h2645.c:1102
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
AVBufferRef * sps_ref[H264_MAX_SPS_COUNT]
Definition: cbs_h264.h:451
int size
Definition: h2645_parse.h:35
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static void cbs_h265_free_slice(void *opaque, uint8_t *content)
Definition: cbs_h2645.c:513
else temp
Definition: vf_mcdeint.c:256
AVBufferRef * data_ref
Definition: cbs_h265.h:188
H264RawPPS * pps[H264_MAX_PPS_COUNT]
Definition: cbs_h264.h:454
AVBufferRef * sps_ref[HEVC_MAX_SPS_COUNT]
Definition: cbs_h265.h:734
void ff_cbs_delete_unit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
Definition: cbs.c:796
uint8_t * data
Definition: cbs_h265.h:544
Sequence parameter set.
Definition: h264_ps.h:44
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:345
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
static int cbs_h265_write_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_h2645.c:1277
static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_h2645.c:946
static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, const int *subscripts, uint32_t *write_to, uint32_t range_min, uint32_t range_max)
Definition: cbs_h2645.c:34
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:644
Picture parameter set.
Definition: h264_ps.h:109
int av_log2(unsigned v)
Definition: intmath.c:26
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:722
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_h2645.c:1389
union H265RawSEIPayload::@56 payload
int version
Definition: avisynth_c.h:858
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static void cbs_h265_free_sei_payload(H265RawSEIPayload *payload)
Definition: cbs_h2645.c:520
CodedBitstreamH2645Context common
Definition: cbs_h265.h:729
static int cbs_write_se_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, const int *subscripts, int32_t value, int32_t range_min, int32_t range_max)
Definition: cbs_h2645.c:185
Macro definitions for various function/variable attributes.
pan-scan rectangle
Definition: h264_sei.h:30
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int trace_enable
Enable trace output during read/write operations.
Definition: cbs.h:206
static void cbs_h265_free_sps(void *opaque, uint8_t *content)
Definition: cbs_h2645.c:499
uint8_t
AVBufferRef * pps_ref[HEVC_MAX_PPS_COUNT]
Definition: cbs_h265.h:735
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:98
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int data_bit_start
Definition: cbs_h265.h:546
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
unregistered user data
Definition: h264_sei.h:33
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding, int use_ref)
Split an input packet into NAL units.
Definition: h2645_parse.c:392
display orientation
Definition: h264_sei.h:36
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:86
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
H265RawSPS * sps[HEVC_MAX_SPS_COUNT]
Definition: cbs_h265.h:737
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:519
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
H264RawSPS * sps[H264_MAX_SPS_COUNT]
Definition: cbs_h264.h:453
#define sp
Definition: regdef.h:63
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
H265RawSEIPayload payload[H265_MAX_SEI_PAYLOADS]
Definition: cbs_h265.h:723
static void cbs_h264_close(CodedBitstreamContext *ctx)
Definition: cbs_h2645.c:1476
Coded bitstream unit structure.
Definition: cbs.h:64
ptrdiff_t size
Definition: opengl_enc.c:100
static void cbs_h264_free_slice(void *opaque, uint8_t *content)
Definition: cbs_h2645.c:485
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:101
static const uint8_t header[24]
Definition: sdr2.c:67
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:162
H265RawPSExtensionData extension_data
Definition: cbs_h265.h:416
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:75
int ff_cbs_insert_unit_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)
Insert a new unit into a fragment with the given data bitstream.
Definition: cbs.c:759
alternative transfer
Definition: h264_sei.h:39
#define av_log(a,...)
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
H.264 common definitions.
int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, H264RawSEIPayload *payload)
Add an SEI message to an access unit.
Definition: cbs_h2645.c:1530
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
buffering period (H.264, D.1.1)
Definition: h264_sei.h:28
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:324
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
static void cbs_h265_free_pps(void *opaque, uint8_t *content)
Definition: cbs_h2645.c:506
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AVBufferRef * data_ref
Definition: cbs_h265.h:547
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
simple assert() macros that are a bit more flexible than ISO C assert().
uint8_t bits
Definition: vp3data.h:202
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
static void cbs_h265_free_vps(void *opaque, uint8_t *content)
Definition: cbs_h2645.c:492
GLsizei count
Definition: opengl_enc.c:108
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:133
#define fail()
Definition: checkasm.h:122
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
H264RawSEIUserDataUnregistered user_data_unregistered
Definition: cbs_h264.h:330
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
Definition: cbs.h:173
static void cbs_h264_free_sei_payload(H264RawSEIPayload *payload)
Definition: cbs_h2645.c:453
const CodedBitstreamType ff_cbs_type_h264
Definition: cbs_h2645.c:1504
static void cbs_h265_close(CodedBitstreamContext *ctx)
Definition: cbs_h2645.c:1489
uint32_t payload_type
Definition: cbs_h265.h:694
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:333
picture timing
Definition: h264_sei.h:29
H265RawPSExtensionData extension_data
Definition: cbs_h265.h:224
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
enum AVCodecID codec_id
Definition: vaapi_decode.c:364
size_t data_size
Definition: cbs_h264.h:433
int type
NAL unit type.
Definition: h2645_parse.h:52
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
#define FF_ARRAY_ELEMS(a)
AVBufferRef * pps_ref[H264_MAX_PPS_COUNT]
Definition: cbs_h264.h:452
H264RawSEIUserDataRegistered user_data_registered
Definition: cbs_h264.h:329
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
uint8_t payload_count
Definition: cbs_h265.h:724
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
H265RawSEIUserDataRegistered user_data_registered
Definition: cbs_h265.h:700
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
AVBufferRef * rbsp_buffer_ref
Definition: h2645_parse.h:75
const uint8_t * data
Definition: h2645_parse.h:36
AVBufferRef * slice_group_id_ref
Definition: cbs_h264.h:199
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Context structure for coded bitstream operations.
Definition: cbs.h:168
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
recovery point (frame # to decoder sync)
Definition: h264_sei.h:34
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
Definition: cbs_h2645.c:325
struct H264RawSEIPayload::@51::@52 other
enum AVCodecID codec_id
Definition: cbs_internal.h:29
registered user data as specified by Rec. ITU-T T.35
Definition: h264_sei.h:32
H264RawSEIPayload payload[H264_MAX_SEI_PAYLOADS]
Definition: cbs_h264.h:347
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
H2645RBSP rbsp
Definition: h2645_parse.h:83
static void cbs_h265_free_sei(void *opaque, uint8_t *content)
Definition: cbs_h2645.c:548
static int cbs_read_se_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, const int *subscripts, int32_t *write_to, int32_t range_min, int32_t range_max)
Definition: cbs_h2645.c:86
AVBufferRef * vps_ref[HEVC_MAX_VPS_COUNT]
Definition: cbs_h265.h:733
void * priv_data
Internal codec-specific data.
Definition: cbs.h:189
AVBufferRef * data_ref
Definition: cbs_h264.h:435
A reference to a data buffer.
Definition: buffer.h:81
H265RawPSExtensionData extension_data
Definition: cbs_h265.h:328
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
static void cbs_h264_free_sei(void *opaque, uint8_t *content)
Definition: cbs_h2645.c:476
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:92
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:94
const CodedBitstreamType ff_cbs_type_h265
Definition: cbs_h2645.c:1517
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:796
const uint8_t * raw_data
Definition: h2645_parse.h:45
int data_bit_start
Definition: cbs_h264.h:434
H265RawSliceHeader header
Definition: cbs_h265.h:542
H264RawSliceHeader header
Definition: cbs_h264.h:430
void ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, CodedBitstreamUnit *nal, int position)
Delete an SEI message from an access unit.
Definition: cbs_h2645.c:1592
int len
union H264RawSEIPayload::@51 payload
H2645NAL * nals
Definition: h2645_parse.h:82
static void cbs_h264_free_pps(void *opaque, uint8_t *content)
Definition: cbs_h2645.c:446
mastering display properties
Definition: h264_sei.h:38
size_t data_size
Definition: cbs_h265.h:545
CodedBitstreamH2645Context common
Definition: cbs_h264.h:447
uint8_t nal_ref_idc
Definition: cbs_h264.h:41
#define av_freep(p)
static int cbs_h264_write_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_h2645.c:1160
void INT64 start
Definition: avisynth_c.h:766
const struct CodedBitstreamType * codec
Internal codec-specific hooks.
Definition: cbs.h:178
int nuh_layer_id
Definition: h2645_parse.h:62
#define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element)
Definition: cbs_h2645.c:750
static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_h2645.c:591
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
H265RawVPS * vps[HEVC_MAX_VPS_COUNT]
Definition: cbs_h265.h:736
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:139
uint8_t nal_unit_type
Definition: cbs_h264.h:42
static int cbs_write_ue_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, const int *subscripts, uint32_t value, uint32_t range_min, uint32_t range_max)
Definition: cbs_h2645.c:142
void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position, const char *str, const int *subscripts, const char *bits, int64_t value)
Definition: cbs.c:435
uint8_t * data
Definition: cbs_h264.h:432
uint8_t payload_count
Definition: cbs_h264.h:348
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:80
const char * name
Definition: opengl_enc.c:102
static int cbs_h2645_fragment_add_nals(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const H2645Packet *packet)
Definition: cbs_h2645.c:557