err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
if (err < 0)
av_packet_unref(out);
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
return err;
}
static void av1_metadata_close(AVBSFContext *bsf)
{
AV1MetadataContext *ctx = bsf->priv_data;
+
+ ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
ff_cbs_close(&ctx->cbc);
}
goto end;
}
- ff_cbs_fragment_uninit(s->cbc, td);
+ ff_cbs_fragment_reset(s->cbc, td);
}
ret = ff_cbs_read(s->cbc, td, data, size);
}
end:
- ff_cbs_fragment_uninit(s->cbc, td);
+ ff_cbs_fragment_reset(s->cbc, td);
s->cbc->log_ctx = NULL;
{
AV1ParseContext *s = ctx->priv_data;
+ ff_cbs_fragment_free(s->cbc, &s->temporal_unit);
ff_cbs_close(&s->cbc);
}
unit->data_bit_padding = 0;
}
-void ff_cbs_fragment_uninit(CodedBitstreamContext *ctx,
- CodedBitstreamFragment *frag)
+void ff_cbs_fragment_reset(CodedBitstreamContext *ctx,
+ CodedBitstreamFragment *frag)
{
int i;
for (i = 0; i < frag->nb_units; i++)
cbs_unit_uninit(ctx, &frag->units[i]);
- av_freep(&frag->units);
frag->nb_units = 0;
av_buffer_unref(&frag->data_ref);
frag->data_bit_padding = 0;
}
+void ff_cbs_fragment_free(CodedBitstreamContext *ctx,
+ CodedBitstreamFragment *frag)
+{
+ ff_cbs_fragment_reset(ctx, frag);
+
+ av_freep(&frag->units);
+ frag->nb_units_allocated = 0;
+}
+
static int cbs_read_fragment_content(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag)
{
{
int err;
- memset(frag, 0, sizeof(*frag));
-
err = cbs_fill_fragment_data(ctx, frag, par->extradata,
par->extradata_size);
if (err < 0)
{
int err;
- memset(frag, 0, sizeof(*frag));
-
if (pkt->buf) {
frag->data_ref = av_buffer_ref(pkt->buf);
if (!frag->data_ref)
{
int err;
- memset(frag, 0, sizeof(*frag));
-
err = cbs_fill_fragment_data(ctx, frag, data, size);
if (err < 0)
return err;
{
CodedBitstreamUnit *units;
- units = av_malloc_array(frag->nb_units + 1, sizeof(*units));
- if (!units)
- return AVERROR(ENOMEM);
+ if (frag->nb_units < frag->nb_units_allocated) {
+ units = frag->units;
+
+ if (position < frag->nb_units)
+ memmove(units + position + 1, units + position,
+ (frag->nb_units - position) * sizeof(*units));
+ } else {
+ units = av_malloc_array(frag->nb_units + 1, sizeof(*units));
+ if (!units)
+ return AVERROR(ENOMEM);
+
+ ++frag->nb_units_allocated;
- if (position > 0)
- memcpy(units, frag->units, position * sizeof(*units));
- if (position < frag->nb_units)
- memcpy(units + position + 1, frag->units + position,
- (frag->nb_units - position) * sizeof(*units));
+ if (position > 0)
+ memcpy(units, frag->units, position * sizeof(*units));
+
+ if (position < frag->nb_units)
+ memcpy(units + position + 1, frag->units + position,
+ (frag->nb_units - position) * sizeof(*units));
+ }
memset(units + position, 0, sizeof(*units));
- av_freep(&frag->units);
- frag->units = units;
+ if (units != frag->units) {
+ av_free(frag->units);
+ frag->units = units;
+ }
+
++frag->nb_units;
return 0;
--frag->nb_units;
- if (frag->nb_units == 0) {
- av_freep(&frag->units);
-
- } else {
+ if (frag->nb_units > 0)
memmove(frag->units + position,
frag->units + position + 1,
(frag->nb_units - position) * sizeof(*frag->units));
- // Don't bother reallocating the unit array.
- }
-
return 0;
}
* and has not been decomposed.
*/
int nb_units;
+
+ /**
+ * Number of allocated units.
+ *
+ * Must always be >= nb_units; designed for internal use by cbs.
+ */
+ int nb_units_allocated;
+
/**
- * Pointer to an array of units of length nb_units.
+ * Pointer to an array of units of length nb_units_allocated.
+ * Only the first nb_units are valid.
*
- * Must be NULL if nb_units is zero.
+ * Must be NULL if nb_units_allocated is zero.
*/
CodedBitstreamUnit *units;
} CodedBitstreamFragment;
* This also updates the internal state, so will need to be called for
* codecs with extradata to read parameter sets necessary for further
* parsing even if the fragment itself is not desired.
+ *
+ * The fragment must have been zeroed or reset via ff_cbs_fragment_reset
+ * before use.
*/
int ff_cbs_read_extradata(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag,
* This also updates the internal state of the coded bitstream context
* with any persistent data from the fragment which may be required to
* read following fragments (e.g. parameter sets).
+ *
+ * The fragment must have been zeroed or reset via ff_cbs_fragment_reset
+ * before use.
*/
int ff_cbs_read_packet(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag,
* This also updates the internal state of the coded bitstream context
* with any persistent data from the fragment which may be required to
* read following fragments (e.g. parameter sets).
+ *
+ * The fragment must have been zeroed or reset via ff_cbs_fragment_reset
+ * before use.
*/
int ff_cbs_read(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag,
/**
- * Free all allocated memory in a fragment.
+ * Free the units contained in a fragment as well as the fragment's
+ * own data buffer, but not the units array itself.
*/
-void ff_cbs_fragment_uninit(CodedBitstreamContext *ctx,
+void ff_cbs_fragment_reset(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag);
+/**
+ * Free the units array of a fragment in addition to what
+ * ff_cbs_fragment_reset does.
+ */
+void ff_cbs_fragment_free(CodedBitstreamContext *ctx,
+ CodedBitstreamFragment *frag);
/**
* Allocate a new internal content buffer of the given size in the unit.
// Don't return packets with nothing in them.
av_packet_free(&in);
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
}
err = ff_cbs_write_packet(ctx->cbc, out, frag);
goto fail;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
av_packet_free(&in);
return err;
av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
}
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
}
return err;
av_freep(&ctx->type_list);
+ ff_cbs_fragment_free(ctx->cbc, &ctx->fragment);
ff_cbs_close(&ctx->cbc);
}
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, au);
+ ff_cbs_fragment_reset(ctx->cbc, au);
av_freep(&displaymatrix_side_data);
if (err < 0)
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, au);
+ ff_cbs_fragment_reset(ctx->cbc, au);
return err;
}
static void h264_metadata_close(AVBSFContext *bsf)
{
H264MetadataContext *ctx = bsf->priv_data;
+
+ ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
ff_cbs_close(&ctx->cbc);
}
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->output, au);
+ ff_cbs_fragment_reset(ctx->output, au);
av_packet_free(&in);
if (err < 0)
av_packet_unref(out);
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->output, au);
+ ff_cbs_fragment_reset(ctx->output, au);
return err;
}
static void h264_redundant_pps_close(AVBSFContext *bsf)
{
H264RedundantPPSContext *ctx = bsf->priv_data;
+
+ ff_cbs_fragment_free(ctx->input, &ctx->access_unit);
ff_cbs_close(&ctx->input);
ff_cbs_close(&ctx->output);
}
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, au);
+ ff_cbs_fragment_reset(ctx->cbc, au);
if (err < 0)
av_packet_unref(out);
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, au);
+ ff_cbs_fragment_reset(ctx->cbc, au);
return err;
}
static void h265_metadata_close(AVBSFContext *bsf)
{
H265MetadataContext *ctx = bsf->priv_data;
+
+ ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
ff_cbs_close(&ctx->cbc);
}
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
if (err < 0)
av_packet_unref(out);
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
return err;
}
static void mpeg2_metadata_close(AVBSFContext *bsf)
{
MPEG2MetadataContext *ctx = bsf->priv_data;
+
+ ff_cbs_fragment_free(ctx->cbc, &ctx->fragment);
ff_cbs_close(&ctx->cbc);
}
err = ff_cbs_read_extradata(ctx->cbc, frag, bsf->par_in);
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
}
return err;
{
TraceHeadersContext *ctx = bsf->priv_data;
+ ff_cbs_fragment_free(ctx->cbc, &ctx->fragment);
ff_cbs_close(&ctx->cbc);
}
err = ff_cbs_read_packet(ctx->cbc, frag, pkt);
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
if (err < 0)
av_packet_unref(pkt);
err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
fail:
- ff_cbs_fragment_uninit(priv->cbc, au);
+ ff_cbs_fragment_reset(priv->cbc, au);
return err;
}
err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au);
fail:
- ff_cbs_fragment_uninit(priv->cbc, au);
+ ff_cbs_fragment_reset(priv->cbc, au);
return err;
}
if (err < 0)
goto fail;
- ff_cbs_fragment_uninit(priv->cbc, au);
+ ff_cbs_fragment_reset(priv->cbc, au);
*type = VAEncPackedHeaderRawData;
return 0;
}
fail:
- ff_cbs_fragment_uninit(priv->cbc, au);
+ ff_cbs_fragment_reset(priv->cbc, au);
return err;
}
{
VAAPIEncodeH264Context *priv = avctx->priv_data;
+ ff_cbs_fragment_free(priv->cbc, &priv->current_access_unit);
ff_cbs_close(&priv->cbc);
av_freep(&priv->sei_identifier_string);
err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
fail:
- ff_cbs_fragment_uninit(priv->cbc, au);
+ ff_cbs_fragment_reset(priv->cbc, au);
return err;
}
err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
fail:
- ff_cbs_fragment_uninit(priv->cbc, au);
+ ff_cbs_fragment_reset(priv->cbc, au);
return err;
}
if (err < 0)
goto fail;
- ff_cbs_fragment_uninit(priv->cbc, au);
+ ff_cbs_fragment_reset(priv->cbc, au);
*type = VAEncPackedHeaderRawData;
return 0;
}
fail:
- ff_cbs_fragment_uninit(priv->cbc, au);
+ ff_cbs_fragment_reset(priv->cbc, au);
return err;
}
{
VAAPIEncodeH265Context *priv = avctx->priv_data;
+ ff_cbs_fragment_free(priv->cbc, &priv->current_access_unit);
ff_cbs_close(&priv->cbc);
return ff_vaapi_encode_close(avctx);
err = 0;
fail:
- ff_cbs_fragment_uninit(priv->cbc, frag);
+ ff_cbs_fragment_reset(priv->cbc, frag);
return err;
}
{
VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
+ ff_cbs_fragment_free(priv->cbc, &priv->current_fragment);
ff_cbs_close(&priv->cbc);
return ff_vaapi_encode_close(avctx);
err = vaapi_encode_mpeg2_write_fragment(avctx, data, data_len, frag);
fail:
- ff_cbs_fragment_uninit(priv->cbc, frag);
+ ff_cbs_fragment_reset(priv->cbc, frag);
return 0;
}
err = vaapi_encode_mpeg2_write_fragment(avctx, data, data_len, frag);
fail:
- ff_cbs_fragment_uninit(priv->cbc, frag);
+ ff_cbs_fragment_reset(priv->cbc, frag);
return 0;
}
{
VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
+ ff_cbs_fragment_free(priv->cbc, &priv->current_fragment);
ff_cbs_close(&priv->cbc);
return ff_vaapi_encode_close(avctx);
err = 0;
fail:
- ff_cbs_fragment_uninit(ctx->cbc, frag);
+ ff_cbs_fragment_reset(ctx->cbc, frag);
if (err < 0)
av_packet_unref(out);
static void vp9_metadata_close(AVBSFContext *bsf)
{
VP9MetadataContext *ctx = bsf->priv_data;
+
+ ff_cbs_fragment_free(ctx->cbc, &ctx->fragment);
ff_cbs_close(&ctx->cbc);
}