#include "cbs_internal.h"
#include "cbs_h264.h"
#include "cbs_h265.h"
-#include "golomb.h"
#include "h264.h"
#include "h264_sei.h"
#include "h2645_parse.h"
#define u(width, name, range_min, range_max) \
xu(width, name, current->name, range_min, range_max, 0)
-#define flag(name) u(1, name, 0, 1)
+#define ub(width, name) \
+ xu(width, name, current->name, 0, MAX_UINT_BITS(width), 0)
+#define flag(name) ub(1, name)
#define ue(name, range_min, range_max) \
xue(name, current->name, range_min, range_max, 0)
+#define i(width, name, range_min, range_max) \
+ xi(width, name, current->name, range_min, range_max, 0)
+#define ib(width, name) \
+ xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0)
#define se(name, range_min, range_max) \
xse(name, current->name, range_min, range_max, 0)
#define us(width, name, range_min, range_max, subs, ...) \
xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
+#define ubs(width, name, subs, ...) \
+ xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
#define flags(name, subs, ...) \
xu(1, name, current->name, 0, 1, subs, __VA_ARGS__)
#define ues(name, range_min, range_max, subs, ...) \
xue(name, current->name, range_min, range_max, subs, __VA_ARGS__)
+#define is(width, name, range_min, range_max, subs, ...) \
+ xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
+#define ibs(width, name, subs, ...) \
+ xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__)
#define ses(name, range_min, range_max, subs, ...) \
xse(name, current->name, range_min, range_max, subs, __VA_ARGS__)
#define RWContext GetBitContext
#define xu(width, name, var, range_min, range_max, subs, ...) do { \
- uint32_t value = range_min; \
+ uint32_t value; \
CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
SUBSCRIPTS(subs, __VA_ARGS__), \
&value, range_min, range_max)); \
var = value; \
} while (0)
#define xue(name, var, range_min, range_max, subs, ...) do { \
- uint32_t value = range_min; \
+ uint32_t value; \
CHECK(cbs_read_ue_golomb(ctx, rw, #name, \
SUBSCRIPTS(subs, __VA_ARGS__), \
&value, range_min, range_max)); \
var = value; \
} while (0)
+#define xi(width, name, var, range_min, range_max, subs, ...) do { \
+ int32_t value; \
+ CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
+ SUBSCRIPTS(subs, __VA_ARGS__), \
+ &value, range_min, range_max)); \
+ var = value; \
+ } while (0)
#define xse(name, var, range_min, range_max, subs, ...) do { \
- int32_t value = range_min; \
+ int32_t value; \
CHECK(cbs_read_se_golomb(ctx, rw, #name, \
SUBSCRIPTS(subs, __VA_ARGS__), \
&value, range_min, range_max)); \
int bits_left = get_bits_left(gbc);
if (bits_left > 8)
return 1;
- if (show_bits(gbc, bits_left) == 1 << (bits_left - 1))
+ if (bits_left == 0)
return 0;
- return 1;
+ if (show_bits(gbc, bits_left) & MAX_UINT_BITS(bits_left - 1))
+ return 1;
+ return 0;
}
#define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))
#undef READWRITE
#undef RWContext
#undef xu
+#undef xi
#undef xue
#undef xse
#undef infer
SUBSCRIPTS(subs, __VA_ARGS__), \
value, range_min, range_max)); \
} while (0)
+#define xi(width, name, var, range_min, range_max, subs, ...) do { \
+ int32_t value = var; \
+ CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
+ SUBSCRIPTS(subs, __VA_ARGS__), \
+ value, range_min, range_max)); \
+ } while (0)
#define xse(name, var, range_min, range_max, subs, ...) do { \
int32_t value = var; \
CHECK(cbs_write_se_golomb(ctx, rw, #name, \
#undef READWRITE
#undef RWContext
#undef xu
+#undef xi
#undef xue
#undef xse
#undef u
+#undef i
#undef flag
#undef ue
#undef se
#undef allocate
-static void cbs_h264_free_pps(void *unit, uint8_t *content)
+static void cbs_h264_free_pps(void *opaque, uint8_t *content)
{
H264RawPPS *pps = (H264RawPPS*)content;
av_buffer_unref(&pps->slice_group_id_ref);
case H264_SEI_TYPE_RECOVERY_POINT:
case H264_SEI_TYPE_DISPLAY_ORIENTATION:
case H264_SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME:
+ case H264_SEI_TYPE_ALTERNATIVE_TRANSFER:
break;
case H264_SEI_TYPE_USER_DATA_REGISTERED:
av_buffer_unref(&payload->payload.user_data_registered.data_ref);
}
}
-static void cbs_h264_free_sei(void *unit, uint8_t *content)
+static void cbs_h264_free_sei(void *opaque, uint8_t *content)
{
H264RawSEI *sei = (H264RawSEI*)content;
int i;
av_freep(&content);
}
-static void cbs_h264_free_slice(void *unit, uint8_t *content)
+static void cbs_h264_free_slice(void *opaque, uint8_t *content)
{
H264RawSlice *slice = (H264RawSlice*)content;
av_buffer_unref(&slice->data_ref);
av_freep(&content);
}
-static void cbs_h265_free_vps(void *unit, uint8_t *content)
+static void cbs_h265_free_vps(void *opaque, uint8_t *content)
{
H265RawVPS *vps = (H265RawVPS*)content;
av_buffer_unref(&vps->extension_data.data_ref);
av_freep(&content);
}
-static void cbs_h265_free_sps(void *unit, uint8_t *content)
+static void cbs_h265_free_sps(void *opaque, uint8_t *content)
{
H265RawSPS *sps = (H265RawSPS*)content;
av_buffer_unref(&sps->extension_data.data_ref);
av_freep(&content);
}
-static void cbs_h265_free_pps(void *unit, uint8_t *content)
+static void cbs_h265_free_pps(void *opaque, uint8_t *content)
{
H265RawPPS *pps = (H265RawPPS*)content;
av_buffer_unref(&pps->extension_data.data_ref);
av_freep(&content);
}
-static void cbs_h265_free_slice(void *unit, uint8_t *content)
+static void cbs_h265_free_slice(void *opaque, uint8_t *content)
{
H265RawSlice *slice = (H265RawSlice*)content;
av_buffer_unref(&slice->data_ref);
case HEVC_SEI_TYPE_MASTERING_DISPLAY_INFO:
case HEVC_SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO:
case HEVC_SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS:
+ case HEVC_SEI_TYPE_ALPHA_CHANNEL_INFO:
break;
case HEVC_SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35:
av_buffer_unref(&payload->payload.user_data_registered.data_ref);
}
}
-static void cbs_h265_free_sei(void *unit, uint8_t *content)
+static void cbs_h265_free_sei(void *opaque, uint8_t *content)
{
H265RawSEI *sei = (H265RawSEI*)content;
int i;
AVBufferRef *ref;
size_t size = nal->size;
+ if (nal->nuh_layer_id > 0)
+ continue;
+
// Remove trailing zeroes.
while (size > 0 && nal->data[size - 1] == 0)
--size;
- av_assert0(size > 0);
+ if (size == 0) {
+ av_log(ctx->log_ctx, AV_LOG_VERBOSE, "Discarding empty 0 NAL unit\n");
+ continue;
+ }
ref = (nal->data == nal->raw_data) ? frag->data_ref
: packet->rbsp.rbsp_buffer_ref;
version = bytestream2_get_byte(&gbc);
if (version != 1) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid AVCC header: "
- "first byte %u.", version);
+ "first byte %u.\n", version);
return AVERROR_INVALIDDATA;
}
version = bytestream2_get_byte(&gbc);
if (version != 1) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid HVCC header: "
- "first byte %u.", version);
+ "first byte %u.\n", version);
return AVERROR_INVALIDDATA;
}
CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \
unsigned int id = ps_var->id_element; \
- if (id > FF_ARRAY_ELEMS(priv->ps_var)) { \
+ if (id >= FF_ARRAY_ELEMS(priv->ps_var)) { \
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid " #ps_name \
" id : %d.\n", id); \
return AVERROR_INVALIDDATA; \
const uint8_t *pos = data + data_bit_start / 8;
av_assert0(data_bit_start >= 0 &&
- 8 * data_size > data_bit_start);
+ data_size > data_bit_start / 8);
if (data_size * 8 + 8 > put_bits_left(pbc))
return AVERROR(ENOSPC);
return 0;
}
-static int cbs_h2645_write_nal_unit(CodedBitstreamContext *ctx,
- CodedBitstreamUnit *unit)
-{
- CodedBitstreamH2645Context *priv = ctx->priv_data;
- enum AVCodecID codec_id = ctx->codec->codec_id;
- PutBitContext pbc;
- int err;
-
- if (!priv->write_buffer) {
- // Initial write buffer size is 1MB.
- priv->write_buffer_size = 1024 * 1024;
-
- reallocate_and_try_again:
- err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
- if (err < 0) {
- av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
- "sufficiently large write buffer (last attempt "
- "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size);
- return err;
- }
- }
-
- init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
-
- if (codec_id == AV_CODEC_ID_H264)
- err = cbs_h264_write_nal_unit(ctx, unit, &pbc);
- else
- err = cbs_h265_write_nal_unit(ctx, unit, &pbc);
-
- if (err == AVERROR(ENOSPC)) {
- // Overflow.
- priv->write_buffer_size *= 2;
- goto reallocate_and_try_again;
- }
- // Overflow but we didn't notice.
- av_assert0(put_bits_count(&pbc) <= 8 * priv->write_buffer_size);
-
- if (err < 0) {
- // Write failed for some other reason.
- return err;
- }
-
- if (put_bits_count(&pbc) % 8)
- unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;
- else
- unit->data_bit_padding = 0;
-
- unit->data_size = (put_bits_count(&pbc) + 7) / 8;
- flush_put_bits(&pbc);
-
- err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);
- if (err < 0)
- return err;
-
- memcpy(unit->data, priv->write_buffer, unit->data_size);
-
- return 0;
-}
-
static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag)
{
max_size = 0;
for (i = 0; i < frag->nb_units; i++) {
// Start code + content with worst-case emulation prevention.
- max_size += 3 + frag->units[i].data_size * 3 / 2;
+ max_size += 4 + frag->units[i].data_size * 3 / 2;
}
- data = av_malloc(max_size + AV_INPUT_BUFFER_PADDING_SIZE);
+ data = av_realloc(NULL, max_size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!data)
return AVERROR(ENOMEM);
ff_h2645_packet_uninit(&h264->common.read_packet);
- av_freep(&h264->common.write_buffer);
-
for (i = 0; i < FF_ARRAY_ELEMS(h264->sps); i++)
av_buffer_unref(&h264->sps_ref[i]);
for (i = 0; i < FF_ARRAY_ELEMS(h264->pps); i++)
ff_h2645_packet_uninit(&h265->common.read_packet);
- av_freep(&h265->common.write_buffer);
-
for (i = 0; i < FF_ARRAY_ELEMS(h265->vps); i++)
av_buffer_unref(&h265->vps_ref[i]);
for (i = 0; i < FF_ARRAY_ELEMS(h265->sps); i++)
.split_fragment = &cbs_h2645_split_fragment,
.read_unit = &cbs_h264_read_nal_unit,
- .write_unit = &cbs_h2645_write_nal_unit,
+ .write_unit = &cbs_h264_write_nal_unit,
.assemble_fragment = &cbs_h2645_assemble_fragment,
.close = &cbs_h264_close,
.split_fragment = &cbs_h2645_split_fragment,
.read_unit = &cbs_h265_read_nal_unit,
- .write_unit = &cbs_h2645_write_nal_unit,
+ .write_unit = &cbs_h265_write_nal_unit,
.assemble_fragment = &cbs_h2645_assemble_fragment,
.close = &cbs_h265_close,
int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx,
CodedBitstreamFragment *au,
- const H264RawSEIPayload *payload)
+ H264RawSEIPayload *payload)
{
- H264RawSEI *sei;
- CodedBitstreamUnit *nal = NULL;
+ H264RawSEI *sei = NULL;
int err, i;
// Find an existing SEI NAL unit to add to.
for (i = 0; i < au->nb_units; i++) {
if (au->units[i].type == H264_NAL_SEI) {
- nal = &au->units[i];
- break;
+ sei = au->units[i].content;
+ if (sei->payload_count < H264_MAX_SEI_PAYLOADS)
+ break;
+
+ sei = NULL;
}
}
- if (nal) {
- sei = nal->content;
- } else {
+ if (!sei) {
// Need to make a new SEI NAL unit. Insert it before the first
// slice data NAL unit; if no slice data, add at the end.
AVBufferRef *sei_ref;
sei = av_mallocz(sizeof(*sei));
- if (!sei)
- return AVERROR(ENOMEM);
+ if (!sei) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
sei->nal_unit_header.nal_unit_type = H264_NAL_SEI;
sei->nal_unit_header.nal_ref_idc = 0;
sei_ref = av_buffer_create((uint8_t*)sei, sizeof(*sei),
- &cbs_h264_free_sei, ctx, 0);
+ &cbs_h264_free_sei, NULL, 0);
if (!sei_ref) {
av_freep(&sei);
- return AVERROR(ENOMEM);
+ err = AVERROR(ENOMEM);
+ goto fail;
}
for (i = 0; i < au->nb_units; i++) {
sei, sei_ref);
av_buffer_unref(&sei_ref);
if (err < 0)
- return err;
- }
-
- if (sei->payload_count >= H264_MAX_SEI_PAYLOADS) {
- av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many payloads in "
- "SEI NAL unit.\n");
- return AVERROR(EINVAL);
+ goto fail;
}
memcpy(&sei->payload[sei->payload_count], payload, sizeof(*payload));
++sei->payload_count;
return 0;
+fail:
+ cbs_h264_free_sei_payload(payload);
+ return err;
}
-int ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx,
- CodedBitstreamFragment *au,
- CodedBitstreamUnit *nal,
- int position)
+void ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx,
+ CodedBitstreamFragment *au,
+ CodedBitstreamUnit *nal,
+ int position)
{
H264RawSEI *sei = nal->content;
if (&au->units[i] == nal)
break;
}
- av_assert0(i < au->nb_units && "NAL unit not in access unit.");
- return ff_cbs_delete_unit(ctx, au, i);
+ ff_cbs_delete_unit(ctx, au, i);
} else {
cbs_h264_free_sei_payload(&sei->payload[position]);
memmove(sei->payload + position,
sei->payload + position + 1,
(sei->payload_count - position) * sizeof(*sei->payload));
-
- return 0;
}
}
projects / ffmpeg / blobdiff