cbs_h2645: Return error if writing fails
[ffmpeg.git] / libavcodec / cbs_h2645.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 "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 "golomb.h"
28 #include "h264.h"
29 #include "h264_sei.h"
30 #include "h2645_parse.h"
31 #include "hevc.h"
32
33
34 static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, BitstreamContext *bc,
35                               const char *name, uint32_t *write_to,
36                               uint32_t range_min, uint32_t range_max)
37 {
38     uint32_t value;
39     int position;
40
41     if (ctx->trace_enable) {
42         char bits[65];
43         unsigned int k;
44         int i, j;
45
46         position = bitstream_tell(bc);
47
48         for (i = 0; i < 32; i++) {
49             k = bitstream_read_bit(bc);
50             bits[i] = k ? '1' : '0';
51             if (k)
52                 break;
53         }
54         if (i >= 32) {
55             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid ue-golomb "
56                    "code found while reading %s: "
57                    "more than 31 zeroes.\n", name);
58             return AVERROR_INVALIDDATA;
59         }
60         value = 1;
61         for (j = 0; j < i; j++) {
62             k = bitstream_read_bit(bc);
63             bits[i + j + 1] = k ? '1' : '0';
64             value = value << 1 | k;
65         }
66         bits[i + j + 1] = 0;
67         --value;
68
69         ff_cbs_trace_syntax_element(ctx, position, name, bits, value);
70     } else {
71         value = get_ue_golomb_long(bc);
72     }
73
74     if (value < range_min || value > range_max) {
75         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
76                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
77                name, value, range_min, range_max);
78         return AVERROR_INVALIDDATA;
79     }
80
81     *write_to = value;
82     return 0;
83 }
84
85 static int cbs_read_se_golomb(CodedBitstreamContext *ctx, BitstreamContext *bc,
86                               const char *name, int32_t *write_to,
87                               int32_t range_min, int32_t range_max)
88 {
89     int32_t value;
90     int position;
91
92     if (ctx->trace_enable) {
93         char bits[65];
94         uint32_t v;
95         unsigned int k;
96         int i, j;
97
98         position = bitstream_tell(bc);
99
100         for (i = 0; i < 32; i++) {
101             k = bitstream_read_bit(bc);
102             bits[i] = k ? '1' : '0';
103             if (k)
104                 break;
105         }
106         if (i >= 32) {
107             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb "
108                    "code found while reading %s: "
109                    "more than 31 zeroes.\n", name);
110             return AVERROR_INVALIDDATA;
111         }
112         v = 1;
113         for (j = 0; j < i; j++) {
114             k = bitstream_read_bit(bc);
115             bits[i + j + 1] = k ? '1' : '0';
116             v = v << 1 | k;
117         }
118         bits[i + j + 1] = 0;
119         if (v & 1)
120             value = -(int32_t)(v / 2);
121         else
122             value = v / 2;
123
124         ff_cbs_trace_syntax_element(ctx, position, name, bits, value);
125     } else {
126         value = get_se_golomb_long(bc);
127     }
128
129     if (value < range_min || value > range_max) {
130         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
131                "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
132                name, value, range_min, range_max);
133         return AVERROR_INVALIDDATA;
134     }
135
136     *write_to = value;
137     return 0;
138 }
139
140 static int cbs_write_ue_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc,
141                                const char *name, uint32_t value,
142                                uint32_t range_min, uint32_t range_max)
143 {
144     int len;
145
146     if (value < range_min || value > range_max) {
147         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
148                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
149                name, value, range_min, range_max);
150         return AVERROR_INVALIDDATA;
151     }
152     av_assert0(value != UINT32_MAX);
153
154     len = av_log2(value + 1);
155     if (put_bits_left(pbc) < 2 * len + 1)
156         return AVERROR(ENOSPC);
157
158     if (ctx->trace_enable) {
159         char bits[65];
160         int i;
161
162         for (i = 0; i < len; i++)
163             bits[i] = '0';
164         bits[len] = '1';
165         for (i = 0; i < len; i++)
166             bits[len + i + 1] = (value + 1) >> (len - i - 1) & 1 ? '1' : '0';
167         bits[len + len + 1] = 0;
168
169         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc), name, bits, value);
170     }
171
172     put_bits(pbc, len, 0);
173     if (len + 1 < 32)
174         put_bits(pbc, len + 1, value + 1);
175     else
176         put_bits32(pbc, value + 1);
177
178     return 0;
179 }
180
181 static int cbs_write_se_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc,
182                                const char *name, int32_t value,
183                                int32_t range_min, int32_t range_max)
184 {
185     int len;
186     uint32_t uvalue;
187
188     if (value < range_min || value > range_max) {
189         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
190                "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
191                name, value, range_min, range_max);
192         return AVERROR_INVALIDDATA;
193     }
194     av_assert0(value != INT32_MIN);
195
196     if (value == 0)
197         uvalue = 0;
198     else if (value > 0)
199         uvalue = 2 * (uint32_t)value - 1;
200     else
201         uvalue = 2 * (uint32_t)-value;
202
203     len = av_log2(uvalue + 1);
204     if (put_bits_left(pbc) < 2 * len + 1)
205         return AVERROR(ENOSPC);
206
207     if (ctx->trace_enable) {
208         char bits[65];
209         int i;
210
211         for (i = 0; i < len; i++)
212             bits[i] = '0';
213         bits[len] = '1';
214         for (i = 0; i < len; i++)
215             bits[len + i + 1] = (uvalue + 1) >> (len - i - 1) & 1 ? '1' : '0';
216         bits[len + len + 1] = 0;
217
218         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc), name, bits, value);
219     }
220
221     put_bits(pbc, len, 0);
222     if (len + 1 < 32)
223         put_bits(pbc, len + 1, uvalue + 1);
224     else
225         put_bits32(pbc, uvalue + 1);
226
227     return 0;
228 }
229
230 #define HEADER(name) do { \
231         ff_cbs_trace_header(ctx, name); \
232     } while (0)
233
234 #define CHECK(call) do { \
235         err = (call); \
236         if (err < 0) \
237             return err; \
238     } while (0)
239
240 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
241 #define FUNC_H264(rw, name) FUNC_NAME(rw, h264, name)
242 #define FUNC_H265(rw, name) FUNC_NAME(rw, h265, name)
243
244
245 #define READ
246 #define READWRITE read
247 #define RWContext BitstreamContext
248
249 #define xu(width, name, var, range_min, range_max) do { \
250         uint32_t value = range_min; \
251         CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
252                                    &value, range_min, range_max)); \
253         var = value; \
254     } while (0)
255 #define xue(name, var, range_min, range_max) do { \
256         uint32_t value = range_min; \
257         CHECK(cbs_read_ue_golomb(ctx, rw, #name, \
258                                  &value, range_min, range_max)); \
259         var = value; \
260     } while (0)
261 #define xse(name, var, range_min, range_max) do { \
262         int32_t value = range_min; \
263         CHECK(cbs_read_se_golomb(ctx, rw, #name, \
264                                  &value, range_min, range_max)); \
265         var = value; \
266     } while (0)
267
268
269 #define u(width, name, range_min, range_max) \
270         xu(width, name, current->name, range_min, range_max)
271 #define flag(name) u(1, name, 0, 1)
272 #define ue(name, range_min, range_max) \
273         xue(name, current->name, range_min, range_max)
274 #define se(name, range_min, range_max) \
275         xse(name, current->name, range_min, range_max)
276
277 #define infer(name, value) do { \
278         current->name = value; \
279     } while (0)
280
281 static int cbs_h2645_read_more_rbsp_data(BitstreamContext *bc)
282 {
283     int bits_left = bitstream_bits_left(bc);
284     if (bits_left > 8)
285         return 1;
286     if (bitstream_peek(bc, bits_left) == 1 << (bits_left - 1))
287         return 0;
288     return 1;
289 }
290
291 #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))
292
293 #define byte_alignment(rw) (bitstream_tell(rw) % 8)
294
295 #define allocate(name, size) do { \
296         name = av_mallocz(size); \
297         if (!name) \
298             return AVERROR(ENOMEM); \
299     } while (0)
300
301 #define FUNC(name) FUNC_H264(READWRITE, name)
302 #include "cbs_h264_syntax_template.c"
303 #undef FUNC
304
305 #define FUNC(name) FUNC_H265(READWRITE, name)
306 #include "cbs_h265_syntax_template.c"
307 #undef FUNC
308
309 #undef READ
310 #undef READWRITE
311 #undef RWContext
312 #undef xu
313 #undef xue
314 #undef xse
315 #undef u
316 #undef flag
317 #undef ue
318 #undef se
319 #undef infer
320 #undef more_rbsp_data
321 #undef byte_alignment
322 #undef allocate
323
324
325 #define WRITE
326 #define READWRITE write
327 #define RWContext PutBitContext
328
329 #define xu(width, name, var, range_min, range_max) do { \
330         uint32_t value = var; \
331         CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
332                                     value, range_min, range_max)); \
333     } while (0)
334 #define xue(name, var, range_min, range_max) do { \
335         uint32_t value = var; \
336         CHECK(cbs_write_ue_golomb(ctx, rw, #name, \
337                                   value, range_min, range_max)); \
338     } while (0)
339 #define xse(name, var, range_min, range_max) do { \
340         int32_t value = var; \
341         CHECK(cbs_write_se_golomb(ctx, rw, #name, \
342                                   value, range_min, range_max)); \
343     } while (0)
344
345 #define u(width, name, range_min, range_max) \
346         xu(width, name, current->name, range_min, range_max)
347 #define flag(name) u(1, name, 0, 1)
348 #define ue(name, range_min, range_max) \
349         xue(name, current->name, range_min, range_max)
350 #define se(name, range_min, range_max) \
351         xse(name, current->name, range_min, range_max)
352
353 #define infer(name, value) do { \
354         if (current->name != (value)) { \
355             av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
356                    "%s does not match inferred value: " \
357                    "%"PRId64", but should be %"PRId64".\n", \
358                    #name, (int64_t)current->name, (int64_t)(value)); \
359         } \
360     } while (0)
361
362 #define more_rbsp_data(var) (var)
363
364 #define byte_alignment(rw) (put_bits_count(rw) % 8)
365
366 #define allocate(name, size) do { \
367         if (!name) { \
368             av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \
369                    "for writing.\n", #name); \
370             return AVERROR_INVALIDDATA; \
371         } \
372     } while (0)
373
374 #define FUNC(name) FUNC_H264(READWRITE, name)
375 #include "cbs_h264_syntax_template.c"
376 #undef FUNC
377
378 #define FUNC(name) FUNC_H265(READWRITE, name)
379 #include "cbs_h265_syntax_template.c"
380 #undef FUNC
381
382 #undef WRITE
383 #undef READWRITE
384 #undef RWContext
385 #undef xu
386 #undef xue
387 #undef xse
388 #undef u
389 #undef flag
390 #undef ue
391 #undef se
392 #undef infer
393 #undef more_rbsp_data
394 #undef byte_alignment
395 #undef allocate
396
397
398 static void cbs_h264_free_sei(H264RawSEI *sei)
399 {
400     int i;
401     for (i = 0; i < sei->payload_count; i++) {
402         H264RawSEIPayload *payload = &sei->payload[i];
403
404         switch (payload->payload_type) {
405         case H264_SEI_TYPE_BUFFERING_PERIOD:
406         case H264_SEI_TYPE_PIC_TIMING:
407         case H264_SEI_TYPE_RECOVERY_POINT:
408         case H264_SEI_TYPE_DISPLAY_ORIENTATION:
409             break;
410         case H264_SEI_TYPE_USER_DATA_REGISTERED:
411             av_freep(&payload->payload.user_data_registered.data);
412             break;
413         case H264_SEI_TYPE_USER_DATA_UNREGISTERED:
414             av_freep(&payload->payload.user_data_unregistered.data);
415             break;
416         default:
417             av_freep(&payload->payload.other.data);
418             break;
419         }
420     }
421 }
422
423 static void cbs_h264_free_slice(H264RawSlice *slice)
424 {
425     av_freep(&slice->data);
426 }
427
428 static void cbs_h264_free_nal_unit(CodedBitstreamUnit *unit)
429 {
430     switch (unit->type) {
431     case H264_NAL_SEI:
432         cbs_h264_free_sei(unit->content);
433         break;
434     case H264_NAL_IDR_SLICE:
435     case H264_NAL_SLICE:
436         cbs_h264_free_slice(unit->content);
437         break;
438     }
439     av_freep(&unit->content);
440 }
441
442 static void cbs_h265_free_nal_unit(CodedBitstreamUnit *unit)
443 {
444     switch (unit->type) {
445     case HEVC_NAL_VPS:
446         av_freep(&((H265RawVPS*)unit->content)->extension_data.data);
447         break;
448     case HEVC_NAL_SPS:
449         av_freep(&((H265RawSPS*)unit->content)->extension_data.data);
450         break;
451     case HEVC_NAL_PPS:
452         av_freep(&((H265RawPPS*)unit->content)->extension_data.data);
453         break;
454     case HEVC_NAL_TRAIL_N:
455     case HEVC_NAL_TRAIL_R:
456     case HEVC_NAL_TSA_N:
457     case HEVC_NAL_TSA_R:
458     case HEVC_NAL_STSA_N:
459     case HEVC_NAL_STSA_R:
460     case HEVC_NAL_RADL_N:
461     case HEVC_NAL_RADL_R:
462     case HEVC_NAL_RASL_N:
463     case HEVC_NAL_RASL_R:
464     case HEVC_NAL_BLA_W_LP:
465     case HEVC_NAL_BLA_W_RADL:
466     case HEVC_NAL_BLA_N_LP:
467     case HEVC_NAL_IDR_W_RADL:
468     case HEVC_NAL_IDR_N_LP:
469     case HEVC_NAL_CRA_NUT:
470         av_freep(&((H265RawSlice*)unit->content)->data);
471         break;
472     }
473     av_freep(&unit->content);
474 }
475
476 static int cbs_h2645_fragment_add_nals(CodedBitstreamContext *ctx,
477                                        CodedBitstreamFragment *frag,
478                                        const H2645Packet *packet)
479 {
480     int err, i;
481
482     for (i = 0; i < packet->nb_nals; i++) {
483         const H2645NAL *nal = &packet->nals[i];
484         uint8_t *data;
485
486         data = av_malloc(nal->size);
487         if (!data)
488             return AVERROR(ENOMEM);
489         memcpy(data, nal->data, nal->size);
490
491         err = ff_cbs_insert_unit_data(ctx, frag, -1, nal->type,
492                                       data, nal->size);
493         if (err < 0) {
494             av_freep(&data);
495             return err;
496         }
497     }
498
499     return 0;
500 }
501
502 static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx,
503                                     CodedBitstreamFragment *frag,
504                                     int header)
505 {
506     enum AVCodecID codec_id = ctx->codec->codec_id;
507     CodedBitstreamH2645Context *priv = ctx->priv_data;
508     GetByteContext gbc;
509     int err;
510
511     av_assert0(frag->data && frag->nb_units == 0);
512     if (frag->data_size == 0)
513         return 0;
514
515     if (header && frag->data[0] && codec_id == AV_CODEC_ID_H264) {
516         // AVCC header.
517         size_t size, start, end;
518         int i, count, version;
519
520         priv->mp4 = 1;
521
522         bytestream2_init(&gbc, frag->data, frag->data_size);
523
524         if (bytestream2_get_bytes_left(&gbc) < 6)
525             return AVERROR_INVALIDDATA;
526
527         version = bytestream2_get_byte(&gbc);
528         if (version != 1) {
529             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid AVCC header: "
530                    "first byte %u.", version);
531             return AVERROR_INVALIDDATA;
532         }
533
534         bytestream2_skip(&gbc, 3);
535         priv->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;
536
537         // SPS array.
538         count = bytestream2_get_byte(&gbc) & 0x1f;
539         start = bytestream2_tell(&gbc);
540         for (i = 0; i < count; i++) {
541             if (bytestream2_get_bytes_left(&gbc) < 2 * (count - i))
542                 return AVERROR_INVALIDDATA;
543             size = bytestream2_get_be16(&gbc);
544             if (bytestream2_get_bytes_left(&gbc) < size)
545                 return AVERROR_INVALIDDATA;
546             bytestream2_skip(&gbc, size);
547         }
548         end = bytestream2_tell(&gbc);
549
550         err = ff_h2645_packet_split(&priv->read_packet,
551                                     frag->data + start, end - start,
552                                     ctx->log_ctx, 1, 2, AV_CODEC_ID_H264);
553         if (err < 0) {
554             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC SPS array.\n");
555             return err;
556         }
557         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);
558         if (err < 0)
559             return err;
560
561         // PPS array.
562         count = bytestream2_get_byte(&gbc);
563         start = bytestream2_tell(&gbc);
564         for (i = 0; i < count; i++) {
565             if (bytestream2_get_bytes_left(&gbc) < 2 * (count - i))
566                 return AVERROR_INVALIDDATA;
567             size = bytestream2_get_be16(&gbc);
568             if (bytestream2_get_bytes_left(&gbc) < size)
569                 return AVERROR_INVALIDDATA;
570             bytestream2_skip(&gbc, size);
571         }
572         end = bytestream2_tell(&gbc);
573
574         err = ff_h2645_packet_split(&priv->read_packet,
575                                     frag->data + start, end - start,
576                                     ctx->log_ctx, 1, 2, AV_CODEC_ID_H264);
577         if (err < 0) {
578             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC PPS array.\n");
579             return err;
580         }
581         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);
582         if (err < 0)
583             return err;
584
585         if (bytestream2_get_bytes_left(&gbc) > 0) {
586             av_log(ctx->log_ctx, AV_LOG_WARNING, "%u bytes left at end of AVCC "
587                    "header.\n", bytestream2_get_bytes_left(&gbc));
588         }
589
590     } else if (header && frag->data[0] && codec_id == AV_CODEC_ID_HEVC) {
591         // HVCC header.
592         size_t size, start, end;
593         int i, j, nb_arrays, nal_unit_type, nb_nals, version;
594
595         priv->mp4 = 1;
596
597         bytestream2_init(&gbc, frag->data, frag->data_size);
598
599         if (bytestream2_get_bytes_left(&gbc) < 23)
600             return AVERROR_INVALIDDATA;
601
602         version = bytestream2_get_byte(&gbc);
603         if (version != 1) {
604             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid HVCC header: "
605                    "first byte %u.", version);
606             return AVERROR_INVALIDDATA;
607         }
608
609         bytestream2_skip(&gbc, 20);
610         priv->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;
611
612         nb_arrays = bytestream2_get_byte(&gbc);
613         for (i = 0; i < nb_arrays; i++) {
614             nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;
615             nb_nals = bytestream2_get_be16(&gbc);
616
617             start = bytestream2_tell(&gbc);
618             for (j = 0; j < nb_nals; j++) {
619                 if (bytestream2_get_bytes_left(&gbc) < 2)
620                     return AVERROR_INVALIDDATA;
621                 size = bytestream2_get_be16(&gbc);
622                 if (bytestream2_get_bytes_left(&gbc) < size)
623                     return AVERROR_INVALIDDATA;
624                 bytestream2_skip(&gbc, size);
625             }
626             end = bytestream2_tell(&gbc);
627
628             err = ff_h2645_packet_split(&priv->read_packet,
629                                         frag->data + start, end - start,
630                                         ctx->log_ctx, 1, 2, AV_CODEC_ID_HEVC);
631             if (err < 0) {
632                 av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split "
633                        "HVCC array %d (%d NAL units of type %d).\n",
634                        i, nb_nals, nal_unit_type);
635                 return err;
636             }
637             err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);
638             if (err < 0)
639                 return err;
640         }
641
642     } else {
643         // Annex B, or later MP4 with already-known parameters.
644
645         err = ff_h2645_packet_split(&priv->read_packet,
646                                     frag->data, frag->data_size,
647                                     ctx->log_ctx,
648                                     priv->mp4, priv->nal_length_size,
649                                     codec_id);
650         if (err < 0)
651             return err;
652
653         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);
654         if (err < 0)
655             return err;
656     }
657
658     return 0;
659 }
660
661 #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \
662 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
663                                                   const H26 ## h26n ## Raw ## ps_name *ps_var)  \
664 { \
665     CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
666     unsigned int id = ps_var->id_element; \
667     if (id > FF_ARRAY_ELEMS(priv->ps_var)) { \
668         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid " #ps_name \
669                " id : %d.\n", id); \
670         return AVERROR_INVALIDDATA; \
671     } \
672     av_freep(&priv->ps_var[id]); \
673     priv->ps_var[id] = av_malloc(sizeof(*ps_var)); \
674     if (!priv->ps_var[id]) \
675         return AVERROR(ENOMEM); \
676     memcpy(priv->ps_var[id], ps_var, sizeof(*ps_var)); \
677     return 0; \
678 }
679
680 cbs_h2645_replace_ps(4, SPS, sps, seq_parameter_set_id)
681 cbs_h2645_replace_ps(4, PPS, pps, pic_parameter_set_id)
682 cbs_h2645_replace_ps(5, VPS, vps, vps_video_parameter_set_id)
683 cbs_h2645_replace_ps(5, SPS, sps, sps_seq_parameter_set_id)
684 cbs_h2645_replace_ps(5, PPS, pps, pps_pic_parameter_set_id)
685
686 static int cbs_h264_read_nal_unit(CodedBitstreamContext *ctx,
687                                   CodedBitstreamUnit *unit)
688 {
689     BitstreamContext bc;
690     int err;
691
692     err = bitstream_init(&bc, unit->data, 8 * unit->data_size);
693     if (err < 0)
694         return err;
695
696     switch (unit->type) {
697     case H264_NAL_SPS:
698         {
699             H264RawSPS *sps;
700
701             sps = av_mallocz(sizeof(*sps));
702             if (!sps)
703                 return AVERROR(ENOMEM);
704             err = cbs_h264_read_sps(ctx, &bc, sps);
705             if (err >= 0)
706                 err = cbs_h264_replace_sps(ctx, sps);
707             if (err < 0) {
708                 av_free(sps);
709                 return err;
710             }
711
712             unit->content = sps;
713         }
714         break;
715
716     case H264_NAL_SPS_EXT:
717         {
718             H264RawSPSExtension *sps_ext;
719
720             sps_ext = av_mallocz(sizeof(*sps_ext));
721             if (!sps_ext)
722                 return AVERROR(ENOMEM);
723             err = cbs_h264_read_sps_extension(ctx, &bc, sps_ext);
724             if (err < 0) {
725                 av_free(sps_ext);
726                 return err;
727             }
728
729             unit->content = sps_ext;
730         }
731         break;
732
733     case H264_NAL_PPS:
734         {
735             H264RawPPS *pps;
736
737             pps = av_mallocz(sizeof(*pps));
738             if (!pps)
739                 return AVERROR(ENOMEM);
740             err = cbs_h264_read_pps(ctx, &bc, pps);
741             if (err >= 0)
742                 err = cbs_h264_replace_pps(ctx, pps);
743             if (err < 0) {
744                 av_free(pps);
745                 return err;
746             }
747
748             unit->content = pps;
749         }
750         break;
751
752     case H264_NAL_SLICE:
753     case H264_NAL_IDR_SLICE:
754     case H264_NAL_AUXILIARY_SLICE:
755         {
756             H264RawSlice *slice;
757             int pos, len;
758
759             slice = av_mallocz(sizeof(*slice));
760             if (!slice)
761                 return AVERROR(ENOMEM);
762             err = cbs_h264_read_slice_header(ctx, &bc, &slice->header);
763             if (err < 0) {
764                 av_free(slice);
765                 return err;
766             }
767
768             pos = bitstream_tell(&bc);
769             len = unit->data_size;
770             if (!unit->data[len - 1]) {
771                 int z;
772                 for (z = 0; z < len && !unit->data[len - z - 1]; z++);
773                 av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
774                        "from slice data.\n", z);
775                 len -= z;
776             }
777
778             slice->data_size = len - pos / 8;
779             slice->data = av_malloc(slice->data_size);
780             if (!slice->data) {
781                 av_free(slice);
782                 return AVERROR(ENOMEM);
783             }
784             memcpy(slice->data,
785                    unit->data + pos / 8, slice->data_size);
786             slice->data_bit_start = pos % 8;
787
788             unit->content = slice;
789         }
790         break;
791
792     case H264_NAL_AUD:
793         {
794             H264RawAUD *aud;
795
796             aud = av_mallocz(sizeof(*aud));
797             if (!aud)
798                 return AVERROR(ENOMEM);
799             err = cbs_h264_read_aud(ctx, &bc, aud);
800             if (err < 0) {
801                 av_free(aud);
802                 return err;
803             }
804
805             unit->content = aud;
806         }
807         break;
808
809     case H264_NAL_SEI:
810         {
811             H264RawSEI *sei;
812
813             sei = av_mallocz(sizeof(*sei));
814             if (!sei)
815                 return AVERROR(ENOMEM);
816             err = cbs_h264_read_sei(ctx, &bc, sei);
817             if (err < 0) {
818                 cbs_h264_free_sei(sei);
819                 return err;
820             }
821
822             unit->content = sei;
823         }
824         break;
825
826     default:
827         return AVERROR(ENOSYS);
828     }
829
830     return 0;
831 }
832
833 static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
834                                   CodedBitstreamUnit *unit)
835 {
836     BitstreamContext bc;
837     int err;
838
839     err = bitstream_init(&bc, unit->data, 8 * unit->data_size);
840     if (err < 0)
841         return err;
842
843     switch (unit->type) {
844     case HEVC_NAL_VPS:
845         {
846             H265RawVPS *vps;
847
848             vps = av_mallocz(sizeof(*vps));
849             if (!vps)
850                 return AVERROR(ENOMEM);
851             err = cbs_h265_read_vps(ctx, &bc, vps);
852             if (err >= 0)
853                 err = cbs_h265_replace_vps(ctx, vps);
854             if (err < 0) {
855                 av_free(vps);
856                 return err;
857             }
858
859             unit->content = vps;
860         }
861         break;
862     case HEVC_NAL_SPS:
863         {
864             H265RawSPS *sps;
865
866             sps = av_mallocz(sizeof(*sps));
867             if (!sps)
868                 return AVERROR(ENOMEM);
869             err = cbs_h265_read_sps(ctx, &bc, sps);
870             if (err >= 0)
871                 err = cbs_h265_replace_sps(ctx, sps);
872             if (err < 0) {
873                 av_free(sps);
874                 return err;
875             }
876
877             unit->content = sps;
878         }
879         break;
880
881     case HEVC_NAL_PPS:
882         {
883             H265RawPPS *pps;
884
885             pps = av_mallocz(sizeof(*pps));
886             if (!pps)
887                 return AVERROR(ENOMEM);
888             err = cbs_h265_read_pps(ctx, &bc, pps);
889             if (err >= 0)
890                 err = cbs_h265_replace_pps(ctx, pps);
891             if (err < 0) {
892                 av_free(pps);
893                 return err;
894             }
895
896             unit->content = pps;
897         }
898         break;
899
900     case HEVC_NAL_TRAIL_N:
901     case HEVC_NAL_TRAIL_R:
902     case HEVC_NAL_TSA_N:
903     case HEVC_NAL_TSA_R:
904     case HEVC_NAL_STSA_N:
905     case HEVC_NAL_STSA_R:
906     case HEVC_NAL_RADL_N:
907     case HEVC_NAL_RADL_R:
908     case HEVC_NAL_RASL_N:
909     case HEVC_NAL_RASL_R:
910     case HEVC_NAL_BLA_W_LP:
911     case HEVC_NAL_BLA_W_RADL:
912     case HEVC_NAL_BLA_N_LP:
913     case HEVC_NAL_IDR_W_RADL:
914     case HEVC_NAL_IDR_N_LP:
915     case HEVC_NAL_CRA_NUT:
916         {
917             H265RawSlice *slice;
918             int pos, len;
919
920             slice = av_mallocz(sizeof(*slice));
921             if (!slice)
922                 return AVERROR(ENOMEM);
923             err = cbs_h265_read_slice_segment_header(ctx, &bc, &slice->header);
924             if (err < 0) {
925                 av_free(slice);
926                 return err;
927             }
928
929             pos = bitstream_tell(&bc);
930             len = unit->data_size;
931             if (!unit->data[len - 1]) {
932                 int z;
933                 for (z = 0; z < len && !unit->data[len - z - 1]; z++);
934                 av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
935                        "from slice data.\n", z);
936                 len -= z;
937             }
938
939             slice->data_size = len - pos / 8;
940             slice->data = av_malloc(slice->data_size);
941             if (!slice->data) {
942                 av_free(slice);
943                 return AVERROR(ENOMEM);
944             }
945             memcpy(slice->data,
946                    unit->data + pos / 8, slice->data_size);
947             slice->data_bit_start = pos % 8;
948
949             unit->content = slice;
950         }
951         break;
952
953     case HEVC_NAL_AUD:
954         {
955             H265RawAUD *aud;
956
957             aud = av_mallocz(sizeof(*aud));
958             if (!aud)
959                 return AVERROR(ENOMEM);
960             err = cbs_h265_read_aud(ctx, &bc, aud);
961             if (err < 0) {
962                 av_free(aud);
963                 return err;
964             }
965
966             unit->content = aud;
967         }
968         break;
969
970     default:
971         return AVERROR(ENOSYS);
972     }
973
974     return 0;
975 }
976
977 static int cbs_h264_write_nal_unit(CodedBitstreamContext *ctx,
978                                    CodedBitstreamUnit *unit,
979                                    PutBitContext *pbc)
980 {
981     int err;
982
983     switch (unit->type) {
984     case H264_NAL_SPS:
985         {
986             H264RawSPS *sps = unit->content;
987
988             err = cbs_h264_write_sps(ctx, pbc, sps);
989             if (err < 0)
990                 return err;
991
992             err = cbs_h264_replace_sps(ctx, sps);
993             if (err < 0)
994                 return err;
995         }
996         break;
997
998     case H264_NAL_SPS_EXT:
999         {
1000             H264RawSPSExtension *sps_ext;
1001
1002             err = cbs_h264_write_sps_extension(ctx, pbc, sps_ext);
1003             if (err < 0)
1004                 return err;
1005         }
1006         break;
1007
1008     case H264_NAL_PPS:
1009         {
1010             H264RawPPS *pps = unit->content;
1011
1012             err = cbs_h264_write_pps(ctx, pbc, pps);
1013             if (err < 0)
1014                 return err;
1015
1016             err = cbs_h264_replace_pps(ctx, pps);
1017             if (err < 0)
1018                 return err;
1019         }
1020         break;
1021
1022     case H264_NAL_SLICE:
1023     case H264_NAL_IDR_SLICE:
1024         {
1025             H264RawSlice *slice = unit->content;
1026             BitstreamContext bc;
1027             int bits_left, end, zeroes;
1028
1029             err = cbs_h264_write_slice_header(ctx, pbc, &slice->header);
1030             if (err < 0)
1031                 return err;
1032
1033             if (slice->data) {
1034                 if (slice->data_size * 8 + 8 > put_bits_left(pbc))
1035                     return AVERROR(ENOSPC);
1036
1037                 bitstream_init(&bc, slice->data, slice->data_size * 8);
1038                 bitstream_skip(&bc, slice->data_bit_start);
1039
1040                 // Copy in two-byte blocks, but stop before copying the
1041                 // rbsp_stop_one_bit in the final byte.
1042                 while (bitstream_bits_left(&bc) > 23)
1043                     put_bits(pbc, 16, bitstream_read(&bc, 16));
1044
1045                 bits_left = bitstream_bits_left(&bc);
1046                 end = bitstream_read(&bc, bits_left);
1047
1048                 // rbsp_stop_one_bit must be present here.
1049                 av_assert0(end);
1050                 zeroes = ff_ctz(end);
1051                 if (bits_left > zeroes + 1)
1052                     put_bits(pbc, bits_left - zeroes - 1,
1053                              end >> (zeroes + 1));
1054                 put_bits(pbc, 1, 1);
1055                 while (put_bits_count(pbc) % 8 != 0)
1056                     put_bits(pbc, 1, 0);
1057             } else {
1058                 // No slice data - that was just the header.
1059                 // (Bitstream may be unaligned!)
1060             }
1061         }
1062         break;
1063
1064     case H264_NAL_AUD:
1065         {
1066             err = cbs_h264_write_aud(ctx, pbc, unit->content);
1067             if (err < 0)
1068                 return err;
1069         }
1070         break;
1071
1072     case H264_NAL_SEI:
1073         {
1074             err = cbs_h264_write_sei(ctx, pbc, unit->content);
1075             if (err < 0)
1076                 return err;
1077         }
1078         break;
1079
1080     default:
1081         av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for "
1082                "NAL unit type %"PRIu32".\n", unit->type);
1083         return AVERROR_PATCHWELCOME;
1084     }
1085
1086     return 0;
1087 }
1088
1089 static int cbs_h265_write_nal_unit(CodedBitstreamContext *ctx,
1090                                    CodedBitstreamUnit *unit,
1091                                    PutBitContext *pbc)
1092 {
1093     int err;
1094
1095     switch (unit->type) {
1096     case HEVC_NAL_VPS:
1097         {
1098             H265RawVPS *vps = unit->content;
1099
1100             err = cbs_h265_write_vps(ctx, pbc, vps);
1101             if (err < 0)
1102                 return err;
1103
1104             err = cbs_h265_replace_vps(ctx, vps);
1105             if (err < 0)
1106                 return err;
1107         }
1108         break;
1109
1110     case HEVC_NAL_SPS:
1111         {
1112             H265RawSPS *sps = unit->content;
1113
1114             err = cbs_h265_write_sps(ctx, pbc, sps);
1115             if (err < 0)
1116                 return err;
1117
1118             err = cbs_h265_replace_sps(ctx, sps);
1119             if (err < 0)
1120                 return err;
1121         }
1122         break;
1123
1124     case HEVC_NAL_PPS:
1125         {
1126             H265RawPPS *pps = unit->content;
1127
1128             err = cbs_h265_write_pps(ctx, pbc, pps);
1129             if (err < 0)
1130                 return err;
1131
1132             err = cbs_h265_replace_pps(ctx, pps);
1133             if (err < 0)
1134                 return err;
1135         }
1136         break;
1137
1138     case HEVC_NAL_TRAIL_N:
1139     case HEVC_NAL_TRAIL_R:
1140     case HEVC_NAL_TSA_N:
1141     case HEVC_NAL_TSA_R:
1142     case HEVC_NAL_STSA_N:
1143     case HEVC_NAL_STSA_R:
1144     case HEVC_NAL_RADL_N:
1145     case HEVC_NAL_RADL_R:
1146     case HEVC_NAL_RASL_N:
1147     case HEVC_NAL_RASL_R:
1148     case HEVC_NAL_BLA_W_LP:
1149     case HEVC_NAL_BLA_W_RADL:
1150     case HEVC_NAL_BLA_N_LP:
1151     case HEVC_NAL_IDR_W_RADL:
1152     case HEVC_NAL_IDR_N_LP:
1153     case HEVC_NAL_CRA_NUT:
1154         {
1155             H265RawSlice *slice = unit->content;
1156             BitstreamContext bc;
1157             int bits_left, end, zeroes;
1158
1159             err = cbs_h265_write_slice_segment_header(ctx, pbc, &slice->header);
1160             if (err < 0)
1161                 return err;
1162
1163             if (slice->data) {
1164                 if (slice->data_size * 8 + 8 > put_bits_left(pbc))
1165                     return AVERROR(ENOSPC);
1166
1167                 bitstream_init(&bc, slice->data, slice->data_size * 8);
1168                 bitstream_skip(&bc, slice->data_bit_start);
1169
1170                 // Copy in two-byte blocks, but stop before copying the
1171                 // rbsp_stop_one_bit in the final byte.
1172                 while (bitstream_bits_left(&bc) > 23)
1173                     put_bits(pbc, 16, bitstream_read(&bc, 16));
1174
1175                 bits_left = bitstream_bits_left(&bc);
1176                 end = bitstream_read(&bc, bits_left);
1177
1178                 // rbsp_stop_one_bit must be present here.
1179                 av_assert0(end);
1180                 zeroes = ff_ctz(end);
1181                 if (bits_left > zeroes + 1)
1182                     put_bits(pbc, bits_left - zeroes - 1,
1183                              end >> (zeroes + 1));
1184                 put_bits(pbc, 1, 1);
1185                 while (put_bits_count(pbc) % 8 != 0)
1186                     put_bits(pbc, 1, 0);
1187             } else {
1188                 // No slice data - that was just the header.
1189             }
1190         }
1191         break;
1192
1193     case HEVC_NAL_AUD:
1194         {
1195             err = cbs_h265_write_aud(ctx, pbc, unit->content);
1196             if (err < 0)
1197                 return err;
1198         }
1199         break;
1200
1201     default:
1202         av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for "
1203                "NAL unit type %d.\n", unit->type);
1204         return AVERROR_PATCHWELCOME;
1205     }
1206
1207     return 0;
1208 }
1209
1210 static int cbs_h2645_write_nal_unit(CodedBitstreamContext *ctx,
1211                                     CodedBitstreamUnit *unit)
1212 {
1213     CodedBitstreamH2645Context *priv = ctx->priv_data;
1214     enum AVCodecID codec_id = ctx->codec->codec_id;
1215     PutBitContext pbc;
1216     int err;
1217
1218     if (!priv->write_buffer) {
1219         // Initial write buffer size is 1MB.
1220         priv->write_buffer_size = 1024 * 1024;
1221
1222     reallocate_and_try_again:
1223         err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
1224         if (err < 0) {
1225             av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
1226                    "sufficiently large write buffer (last attempt "
1227                    "%zu bytes).\n", priv->write_buffer_size);
1228             return err;
1229         }
1230     }
1231
1232     init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
1233
1234     if (codec_id == AV_CODEC_ID_H264)
1235         err = cbs_h264_write_nal_unit(ctx, unit, &pbc);
1236     else
1237         err = cbs_h265_write_nal_unit(ctx, unit, &pbc);
1238
1239     if (err == AVERROR(ENOSPC)) {
1240         // Overflow.
1241         priv->write_buffer_size *= 2;
1242         goto reallocate_and_try_again;
1243     }
1244     // Overflow but we didn't notice.
1245     av_assert0(put_bits_count(&pbc) <= 8 * priv->write_buffer_size);
1246
1247     if (err < 0) {
1248         // Write failed for some other reason.
1249         return err;
1250     }
1251
1252     if (put_bits_count(&pbc) % 8)
1253         unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;
1254     else
1255         unit->data_bit_padding = 0;
1256
1257     unit->data_size = (put_bits_count(&pbc) + 7) / 8;
1258     flush_put_bits(&pbc);
1259
1260     err = av_reallocp(&unit->data, unit->data_size);
1261     if (err < 0)
1262         return err;
1263
1264     memcpy(unit->data, priv->write_buffer, unit->data_size);
1265
1266     return 0;
1267 }
1268
1269 static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
1270                                        CodedBitstreamFragment *frag)
1271 {
1272     uint8_t *data;
1273     size_t max_size, dp, sp;
1274     int err, i, zero_run;
1275
1276     for (i = 0; i < frag->nb_units; i++) {
1277         // Data should already all have been written when we get here.
1278         av_assert0(frag->units[i].data);
1279     }
1280
1281     max_size = 0;
1282     for (i = 0; i < frag->nb_units; i++) {
1283         // Start code + content with worst-case emulation prevention.
1284         max_size += 3 + frag->units[i].data_size * 3 / 2;
1285     }
1286
1287     data = av_malloc(max_size);
1288     if (!data)
1289         return AVERROR(ENOMEM);
1290
1291     dp = 0;
1292     for (i = 0; i < frag->nb_units; i++) {
1293         CodedBitstreamUnit *unit = &frag->units[i];
1294
1295         if (unit->data_bit_padding > 0) {
1296             if (i < frag->nb_units - 1)
1297                 av_log(ctx->log_ctx, AV_LOG_WARNING, "Probably invalid "
1298                        "unaligned padding on non-final NAL unit.\n");
1299             else
1300                 frag->data_bit_padding = unit->data_bit_padding;
1301         }
1302
1303         if ((ctx->codec->codec_id == AV_CODEC_ID_H264 &&
1304              (unit->type == H264_NAL_SPS ||
1305               unit->type == H264_NAL_PPS)) ||
1306             (ctx->codec->codec_id == AV_CODEC_ID_HEVC &&
1307              (unit->type == HEVC_NAL_VPS ||
1308               unit->type == HEVC_NAL_SPS ||
1309               unit->type == HEVC_NAL_PPS)) ||
1310             i == 0 /* (Assume this is the start of an access unit.) */) {
1311             // zero_byte
1312             data[dp++] = 0;
1313         }
1314         // start_code_prefix_one_3bytes
1315         data[dp++] = 0;
1316         data[dp++] = 0;
1317         data[dp++] = 1;
1318
1319         zero_run = 0;
1320         for (sp = 0; sp < unit->data_size; sp++) {
1321             if (zero_run < 2) {
1322                 if (unit->data[sp] == 0)
1323                     ++zero_run;
1324                 else
1325                     zero_run = 0;
1326             } else {
1327                 if ((unit->data[sp] & ~3) == 0) {
1328                     // emulation_prevention_three_byte
1329                     data[dp++] = 3;
1330                 }
1331                 zero_run = unit->data[sp] == 0;
1332             }
1333             data[dp++] = unit->data[sp];
1334         }
1335     }
1336
1337     av_assert0(dp <= max_size);
1338     err = av_reallocp(&data, dp);
1339     if (err)
1340         return err;
1341
1342     frag->data = data;
1343     frag->data_size = dp;
1344
1345     return 0;
1346 }
1347
1348 static void cbs_h264_close(CodedBitstreamContext *ctx)
1349 {
1350     CodedBitstreamH264Context *h264 = ctx->priv_data;
1351     int i;
1352
1353     ff_h2645_packet_uninit(&h264->common.read_packet);
1354
1355     av_freep(&h264->common.write_buffer);
1356
1357     for (i = 0; i < FF_ARRAY_ELEMS(h264->sps); i++)
1358         av_freep(&h264->sps[i]);
1359     for (i = 0; i < FF_ARRAY_ELEMS(h264->pps); i++)
1360         av_freep(&h264->pps[i]);
1361 }
1362
1363 static void cbs_h265_close(CodedBitstreamContext *ctx)
1364 {
1365     CodedBitstreamH265Context *h265 = ctx->priv_data;
1366     int i;
1367
1368     ff_h2645_packet_uninit(&h265->common.read_packet);
1369
1370     av_freep(&h265->common.write_buffer);
1371
1372     for (i = 0; i < FF_ARRAY_ELEMS(h265->vps); i++)
1373         av_freep(&h265->vps[i]);
1374     for (i = 0; i < FF_ARRAY_ELEMS(h265->sps); i++)
1375         av_freep(&h265->sps[i]);
1376     for (i = 0; i < FF_ARRAY_ELEMS(h265->pps); i++)
1377         av_freep(&h265->pps[i]);
1378 }
1379
1380 const CodedBitstreamType ff_cbs_type_h264 = {
1381     .codec_id          = AV_CODEC_ID_H264,
1382
1383     .priv_data_size    = sizeof(CodedBitstreamH264Context),
1384
1385     .split_fragment    = &cbs_h2645_split_fragment,
1386     .read_unit         = &cbs_h264_read_nal_unit,
1387     .write_unit        = &cbs_h2645_write_nal_unit,
1388     .assemble_fragment = &cbs_h2645_assemble_fragment,
1389
1390     .free_unit         = &cbs_h264_free_nal_unit,
1391     .close             = &cbs_h264_close,
1392 };
1393
1394 const CodedBitstreamType ff_cbs_type_h265 = {
1395     .codec_id          = AV_CODEC_ID_HEVC,
1396
1397     .priv_data_size    = sizeof(CodedBitstreamH265Context),
1398
1399     .split_fragment    = &cbs_h2645_split_fragment,
1400     .read_unit         = &cbs_h265_read_nal_unit,
1401     .write_unit        = &cbs_h2645_write_nal_unit,
1402     .assemble_fragment = &cbs_h2645_assemble_fragment,
1403
1404     .free_unit         = &cbs_h265_free_nal_unit,
1405     .close             = &cbs_h265_close,
1406 };