return 0;
}
+// payload_extension_present() - true if we are before the last 1-bit
+// in the payload structure, which must be in the last byte.
+static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t payload_size,
+ int cur_pos)
+{
+ int bits_left = payload_size * 8 - cur_pos;
+ return (bits_left > 0 &&
+ (bits_left > 7 || show_bits(gbc, bits_left) & MAX_UINT_BITS(bits_left - 1)));
+}
+
#define HEADER(name) do { \
ff_cbs_trace_header(ctx, name); \
} while (0)
#define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
#define u(width, name, range_min, range_max) \
- xu(width, name, current->name, range_min, range_max, 0)
+ xu(width, name, current->name, range_min, range_max, 0, )
#define ub(width, name) \
- xu(width, name, current->name, 0, MAX_UINT_BITS(width), 0)
+ 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)
+ 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)
+ 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)
+ 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)
+ 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 fixed(width, name, value) do { \
av_unused uint32_t fixed_value = value; \
- xu(width, name, fixed_value, value, value, 0); \
+ xu(width, name, fixed_value, value, value, 0, ); \
} while (0)
#define infer(name, value) do { \
if (current->name != (value)) { \
- av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
+ av_log(ctx->log_ctx, AV_LOG_ERROR, \
"%s does not match inferred value: " \
"%"PRId64", but should be %"PRId64".\n", \
#name, (int64_t)current->name, (int64_t)(value)); \
+ return AVERROR_INVALIDDATA; \
} \
} while (0)
av_buffer_unref(&payload->payload.other.data_ref);
break;
}
+ av_buffer_unref(&payload->extension_data.data_ref);
}
static void cbs_h265_free_sei(void *opaque, uint8_t *content)
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;
- err = ff_cbs_insert_unit_data(ctx, frag, -1, nal->type,
+ err = ff_cbs_insert_unit_data(frag, -1, nal->type,
(uint8_t*)nal->data, size, ref);
if (err < 0)
return err;
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; \
{
H264RawSPS *sps;
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*sps), NULL);
+ err = ff_cbs_alloc_unit_content(unit, sizeof(*sps), NULL);
if (err < 0)
return err;
sps = unit->content;
case H264_NAL_SPS_EXT:
{
- err = ff_cbs_alloc_unit_content(ctx, unit,
+ err = ff_cbs_alloc_unit_content(unit,
sizeof(H264RawSPSExtension),
NULL);
if (err < 0)
{
H264RawPPS *pps;
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),
+ err = ff_cbs_alloc_unit_content(unit, sizeof(*pps),
&cbs_h264_free_pps);
if (err < 0)
return err;
H264RawSlice *slice;
int pos, len;
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),
+ err = ff_cbs_alloc_unit_content(unit, sizeof(*slice),
&cbs_h264_free_slice);
if (err < 0)
return err;
if (err < 0)
return err;
+ if (!cbs_h2645_read_more_rbsp_data(&gbc))
+ return AVERROR_INVALIDDATA;
+
pos = get_bits_count(&gbc);
len = unit->data_size;
- if (!unit->data[len - 1]) {
- int z;
- for (z = 0; z < len && !unit->data[len - z - 1]; z++);
- av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
- "from slice data.\n", z);
- len -= z;
- }
slice->data_size = len - pos / 8;
slice->data_ref = av_buffer_ref(unit->data_ref);
case H264_NAL_AUD:
{
- err = ff_cbs_alloc_unit_content(ctx, unit,
+ err = ff_cbs_alloc_unit_content(unit,
sizeof(H264RawAUD), NULL);
if (err < 0)
return err;
case H264_NAL_SEI:
{
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(H264RawSEI),
+ err = ff_cbs_alloc_unit_content(unit, sizeof(H264RawSEI),
&cbs_h264_free_sei);
if (err < 0)
return err;
case H264_NAL_FILLER_DATA:
{
- err = ff_cbs_alloc_unit_content(ctx, unit,
+ err = ff_cbs_alloc_unit_content(unit,
sizeof(H264RawFiller), NULL);
if (err < 0)
return err;
case H264_NAL_END_SEQUENCE:
case H264_NAL_END_STREAM:
{
- err = ff_cbs_alloc_unit_content(ctx, unit,
+ err = ff_cbs_alloc_unit_content(unit,
sizeof(H264RawNALUnitHeader),
NULL);
if (err < 0)
{
H265RawVPS *vps;
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*vps),
+ err = ff_cbs_alloc_unit_content(unit, sizeof(*vps),
&cbs_h265_free_vps);
if (err < 0)
return err;
{
H265RawSPS *sps;
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*sps),
+ err = ff_cbs_alloc_unit_content(unit, sizeof(*sps),
&cbs_h265_free_sps);
if (err < 0)
return err;
{
H265RawPPS *pps;
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),
+ err = ff_cbs_alloc_unit_content(unit, sizeof(*pps),
&cbs_h265_free_pps);
if (err < 0)
return err;
H265RawSlice *slice;
int pos, len;
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),
+ err = ff_cbs_alloc_unit_content(unit, sizeof(*slice),
&cbs_h265_free_slice);
if (err < 0)
return err;
if (err < 0)
return err;
+ if (!cbs_h2645_read_more_rbsp_data(&gbc))
+ return AVERROR_INVALIDDATA;
+
pos = get_bits_count(&gbc);
len = unit->data_size;
- if (!unit->data[len - 1]) {
- int z;
- for (z = 0; z < len && !unit->data[len - z - 1]; z++);
- av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
- "from slice data.\n", z);
- len -= z;
- }
slice->data_size = len - pos / 8;
slice->data_ref = av_buffer_ref(unit->data_ref);
case HEVC_NAL_AUD:
{
- err = ff_cbs_alloc_unit_content(ctx, unit,
+ err = ff_cbs_alloc_unit_content(unit,
sizeof(H265RawAUD), NULL);
if (err < 0)
return err;
case HEVC_NAL_SEI_PREFIX:
case HEVC_NAL_SEI_SUFFIX:
{
- err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(H265RawSEI),
+ err = ff_cbs_alloc_unit_content(unit, sizeof(H265RawSEI),
&cbs_h265_free_sei);
if (err < 0)
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_realloc(NULL, max_size + AV_INPUT_BUFFER_PADDING_SIZE);
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,
+int ff_cbs_h264_add_sei_message(CodedBitstreamFragment *au,
H264RawSEIPayload *payload)
{
H264RawSEI *sei = NULL;
break;
}
- err = ff_cbs_insert_unit_content(ctx, au, i, H264_NAL_SEI,
+ err = ff_cbs_insert_unit_content(au, i, H264_NAL_SEI,
sei, sei_ref);
av_buffer_unref(&sei_ref);
if (err < 0)
return err;
}
-void ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx,
- CodedBitstreamFragment *au,
+void ff_cbs_h264_delete_sei_message(CodedBitstreamFragment *au,
CodedBitstreamUnit *nal,
int position)
{
break;
}
- ff_cbs_delete_unit(ctx, au, i);
+ ff_cbs_delete_unit(au, i);
} else {
cbs_h264_free_sei_payload(&sei->payload[position]);
projects / ffmpeg / blobdiff