virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

avcodec/bsf: Add FFBitStreamFilter, hide internals of BSFs

Browse Source 
This patch is analogous to 20f9727018:
It hides the internal part of AVBitStreamFilter by adding a new
internal structure FFBitStreamFilter (declared in bsf_internal.h)
that has an AVBitStreamFilter as its first member; the internal
part of AVBitStreamFilter is moved to this new structure.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt 2022-03-21 22:25:27 +01:00
parent 1dcd0adedd
commit f4098bbc3b
43 changed files with 219 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
configure vendored
View File

@ -3992,7 +3992,7 @@ CODEC_LIST="
$DECODER_LIST
"
PARSER_LIST=$(find_things_extern parser AVCodecParser libavcodec/parsers.c)
BSF_LIST=$(find_things_extern bsf AVBitStreamFilter libavcodec/bitstream_filters.c)
BSF_LIST=$(find_things_extern bsf FFBitStreamFilter libavcodec/bitstream_filters.c)
HWACCEL_LIST=$(find_things_extern hwaccel AVHWAccel libavcodec/hwaccels.h)
PROTOCOL_LIST=$(find_things_extern protocol URLProtocol libavformat/protocols.c)
@ -7869,7 +7869,7 @@ print_enabled_components(){
print_enabled_components libavfilter/filter_list.c AVFilter filter_list $FILTER_LIST
print_enabled_components libavcodec/codec_list.c FFCodec codec_list $CODEC_LIST
print_enabled_components libavcodec/parser_list.c AVCodecParser parser_list $PARSER_LIST
print_enabled_components libavcodec/bsf_list.c AVBitStreamFilter bitstream_filters $BSF_LIST
print_enabled_components libavcodec/bsf_list.c FFBitStreamFilter bitstream_filters $BSF_LIST
print_enabled_components libavformat/demuxer_list.c AVInputFormat demuxer_list $DEMUXER_LIST
print_enabled_components libavformat/muxer_list.c AVOutputFormat muxer_list $MUXER_LIST
print_enabled_components libavdevice/indev_list.c AVInputFormat indev_list $INDEV_LIST

6
libavcodec/aac_adtstoasc_bsf.c
View File

@ -148,10 +148,10 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_AAC, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_aac_adtstoasc_bsf = {
.name = "aac_adtstoasc",
const FFBitStreamFilter ff_aac_adtstoasc_bsf = {
.p.name = "aac_adtstoasc",
.p.codec_ids = codec_ids,
.priv_data_size = sizeof(AACBSFContext),
.init = aac_adtstoasc_init,
.filter = aac_adtstoasc_filter,
.codec_ids = codec_ids,
};

6
libavcodec/av1_frame_merge_bsf.c
View File

@ -156,12 +156,12 @@ static const enum AVCodecID av1_frame_merge_codec_ids[] = {
AV_CODEC_ID_AV1, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_av1_frame_merge_bsf = {
.name = "av1_frame_merge",
const FFBitStreamFilter ff_av1_frame_merge_bsf = {
.p.name = "av1_frame_merge",
.p.codec_ids = av1_frame_merge_codec_ids,
.priv_data_size = sizeof(AV1FMergeContext),
.init = av1_frame_merge_init,
.flush = av1_frame_merge_flush,
.close = av1_frame_merge_close,
.filter = av1_frame_merge_filter,
.codec_ids = av1_frame_merge_codec_ids,
};

6
libavcodec/av1_frame_split_bsf.c
View File

@ -250,12 +250,12 @@ static const enum AVCodecID av1_frame_split_codec_ids[] = {
AV_CODEC_ID_AV1, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_av1_frame_split_bsf = {
.name = "av1_frame_split",
const FFBitStreamFilter ff_av1_frame_split_bsf = {
.p.name = "av1_frame_split",
.p.codec_ids = av1_frame_split_codec_ids,
.priv_data_size = sizeof(AV1FSplitContext),
.init = av1_frame_split_init,
.flush = av1_frame_split_flush,
.close = av1_frame_split_close,
.filter = av1_frame_split_filter,
.codec_ids = av1_frame_split_codec_ids,
};

9
libavcodec/av1_metadata_bsf.c
View File

@ -20,6 +20,7 @@
#include "libavutil/opt.h"
#include "bsf.h"
#include "bsf_internal.h"
#include "cbs.h"
#include "cbs_bsf.h"
#include "cbs_av1.h"
@ -219,12 +220,12 @@ static const enum AVCodecID av1_metadata_codec_ids[] = {
AV_CODEC_ID_AV1, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_av1_metadata_bsf = {
.name = "av1_metadata",
const FFBitStreamFilter ff_av1_metadata_bsf = {
.p.name = "av1_metadata",
.p.codec_ids = av1_metadata_codec_ids,
.p.priv_class = &av1_metadata_class,
.priv_data_size = sizeof(AV1MetadataContext),
.priv_class = &av1_metadata_class,
.init = &av1_metadata_init,
.close = &ff_cbs_bsf_generic_close,
.filter = &ff_cbs_bsf_generic_filter,
.codec_ids = av1_metadata_codec_ids,
};

85
libavcodec/bitstream_filters.c
View File

@ -24,56 +24,57 @@
#include "bsf.h"
#include "bsf_internal.h"
extern const AVBitStreamFilter ff_aac_adtstoasc_bsf;
extern const AVBitStreamFilter ff_av1_frame_merge_bsf;
extern const AVBitStreamFilter ff_av1_frame_split_bsf;
extern const AVBitStreamFilter ff_av1_metadata_bsf;
extern const AVBitStreamFilter ff_chomp_bsf;
extern const AVBitStreamFilter ff_dump_extradata_bsf;
extern const AVBitStreamFilter ff_dca_core_bsf;
extern const AVBitStreamFilter ff_dv_error_marker_bsf;
extern const AVBitStreamFilter ff_eac3_core_bsf;
extern const AVBitStreamFilter ff_extract_extradata_bsf;
extern const AVBitStreamFilter ff_filter_units_bsf;
extern const AVBitStreamFilter ff_h264_metadata_bsf;
extern const AVBitStreamFilter ff_h264_mp4toannexb_bsf;
extern const AVBitStreamFilter ff_h264_redundant_pps_bsf;
extern const AVBitStreamFilter ff_hapqa_extract_bsf;
extern const AVBitStreamFilter ff_hevc_metadata_bsf;
extern const AVBitStreamFilter ff_hevc_mp4toannexb_bsf;
extern const AVBitStreamFilter ff_imx_dump_header_bsf;
extern const AVBitStreamFilter ff_mjpeg2jpeg_bsf;
extern const AVBitStreamFilter ff_mjpega_dump_header_bsf;
extern const AVBitStreamFilter ff_mp3_header_decompress_bsf;
extern const AVBitStreamFilter ff_mpeg2_metadata_bsf;
extern const AVBitStreamFilter ff_mpeg4_unpack_bframes_bsf;
extern const AVBitStreamFilter ff_mov2textsub_bsf;
extern const AVBitStreamFilter ff_noise_bsf;
extern const AVBitStreamFilter ff_null_bsf;
extern const AVBitStreamFilter ff_opus_metadata_bsf;
extern const AVBitStreamFilter ff_pcm_rechunk_bsf;
extern const AVBitStreamFilter ff_prores_metadata_bsf;
extern const AVBitStreamFilter ff_remove_extradata_bsf;
extern const AVBitStreamFilter ff_setts_bsf;
extern const AVBitStreamFilter ff_text2movsub_bsf;
extern const AVBitStreamFilter ff_trace_headers_bsf;
extern const AVBitStreamFilter ff_truehd_core_bsf;
extern const AVBitStreamFilter ff_vp9_metadata_bsf;
extern const AVBitStreamFilter ff_vp9_raw_reorder_bsf;
extern const AVBitStreamFilter ff_vp9_superframe_bsf;
extern const AVBitStreamFilter ff_vp9_superframe_split_bsf;
extern const FFBitStreamFilter ff_aac_adtstoasc_bsf;
extern const FFBitStreamFilter ff_av1_frame_merge_bsf;
extern const FFBitStreamFilter ff_av1_frame_split_bsf;
extern const FFBitStreamFilter ff_av1_metadata_bsf;
extern const FFBitStreamFilter ff_chomp_bsf;
extern const FFBitStreamFilter ff_dump_extradata_bsf;
extern const FFBitStreamFilter ff_dca_core_bsf;
extern const FFBitStreamFilter ff_dv_error_marker_bsf;
extern const FFBitStreamFilter ff_eac3_core_bsf;
extern const FFBitStreamFilter ff_extract_extradata_bsf;
extern const FFBitStreamFilter ff_filter_units_bsf;
extern const FFBitStreamFilter ff_h264_metadata_bsf;
extern const FFBitStreamFilter ff_h264_mp4toannexb_bsf;
extern const FFBitStreamFilter ff_h264_redundant_pps_bsf;
extern const FFBitStreamFilter ff_hapqa_extract_bsf;
extern const FFBitStreamFilter ff_hevc_metadata_bsf;
extern const FFBitStreamFilter ff_hevc_mp4toannexb_bsf;
extern const FFBitStreamFilter ff_imx_dump_header_bsf;
extern const FFBitStreamFilter ff_mjpeg2jpeg_bsf;
extern const FFBitStreamFilter ff_mjpega_dump_header_bsf;
extern const FFBitStreamFilter ff_mp3_header_decompress_bsf;
extern const FFBitStreamFilter ff_mpeg2_metadata_bsf;
extern const FFBitStreamFilter ff_mpeg4_unpack_bframes_bsf;
extern const FFBitStreamFilter ff_mov2textsub_bsf;
extern const FFBitStreamFilter ff_noise_bsf;
extern const FFBitStreamFilter ff_null_bsf;
extern const FFBitStreamFilter ff_opus_metadata_bsf;
extern const FFBitStreamFilter ff_pcm_rechunk_bsf;
extern const FFBitStreamFilter ff_prores_metadata_bsf;
extern const FFBitStreamFilter ff_remove_extradata_bsf;
extern const FFBitStreamFilter ff_setts_bsf;
extern const FFBitStreamFilter ff_text2movsub_bsf;
extern const FFBitStreamFilter ff_trace_headers_bsf;
extern const FFBitStreamFilter ff_truehd_core_bsf;
extern const FFBitStreamFilter ff_vp9_metadata_bsf;
extern const FFBitStreamFilter ff_vp9_raw_reorder_bsf;
extern const FFBitStreamFilter ff_vp9_superframe_bsf;
extern const FFBitStreamFilter ff_vp9_superframe_split_bsf;
#include "libavcodec/bsf_list.c"
const AVBitStreamFilter *av_bsf_iterate(void **opaque)
{
uintptr_t i = (uintptr_t)*opaque;
const AVBitStreamFilter *f = bitstream_filters[i];
const FFBitStreamFilter *f = bitstream_filters[i];
if (f)
if (f) {
*opaque = (void*)(i + 1);
return f;
return &f->p;
}
return NULL;
}
const AVBitStreamFilter *av_bsf_get_by_name(const char *name)

38
libavcodec/bsf.c
View File

@ -18,7 +18,6 @@
#include <string.h>
#include "config.h"
#include "config_components.h"
#include "libavutil/avassert.h"
@ -35,6 +34,11 @@
#define IS_EMPTY(pkt) (!(pkt)->data && !(pkt)->side_data_elems)
static av_always_inline const FFBitStreamFilter *ff_bsf(const AVBitStreamFilter *bsf)
{
return (const FFBitStreamFilter*)bsf;
}
typedef struct FFBSFContext {
AVBSFContext pub;
AVPacket *buffer_pkt;
@ -57,8 +61,8 @@ void av_bsf_free(AVBSFContext **pctx)
bsfi = ffbsfcontext(ctx);
if (ctx->priv_data) {
if (ctx->filter->close)
ctx->filter->close(ctx);
if (ff_bsf(ctx->filter)->close)
ff_bsf(ctx->filter)->close(ctx);
if (ctx->filter->priv_class)
av_opt_free(ctx->priv_data);
av_freep(&ctx->priv_data);
@ -119,8 +123,8 @@ int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
goto fail;
}
/* allocate priv data and init private options */
if (filter->priv_data_size) {
ctx->priv_data = av_mallocz(filter->priv_data_size);
if (ff_bsf(filter)->priv_data_size) {
ctx->priv_data = av_mallocz(ff_bsf(filter)->priv_data_size);
if (!ctx->priv_data) {
ret = AVERROR(ENOMEM);
goto fail;
@ -175,8 +179,8 @@ int av_bsf_init(AVBSFContext *ctx)
ctx->time_base_out = ctx->time_base_in;
if (ctx->filter->init) {
ret = ctx->filter->init(ctx);
if (ff_bsf(ctx->filter)->init) {
ret = ff_bsf(ctx->filter)->init(ctx);
if (ret < 0)
return ret;
}
@ -192,8 +196,8 @@ void av_bsf_flush(AVBSFContext *ctx)
av_packet_unref(bsfi->buffer_pkt);
if (ctx->filter->flush)
ctx->filter->flush(ctx);
if (ff_bsf(ctx->filter)->flush)
ff_bsf(ctx->filter)->flush(ctx);
}
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
@ -226,7 +230,7 @@ int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
{
return ctx->filter->filter(ctx, pkt);
return ff_bsf(ctx->filter)->filter(ctx, pkt);
}
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
@ -399,10 +403,10 @@ static const AVClass bsf_list_class = {
.version = LIBAVUTIL_VERSION_INT,
};
static const AVBitStreamFilter list_bsf = {
.name = "bsf_list",
static const FFBitStreamFilter list_bsf = {
.p.name = "bsf_list",
.p.priv_class = &bsf_list_class,
.priv_data_size = sizeof(BSFListContext),
.priv_class = &bsf_list_class,
.init = bsf_list_init,
.filter = bsf_list_filter,
.flush = bsf_list_flush,
@ -495,7 +499,7 @@ int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf)
goto end;
}
ret = av_bsf_alloc(&list_bsf, bsf);
ret = av_bsf_alloc(&list_bsf.p, bsf);
if (ret < 0)
return ret;
@ -550,9 +554,9 @@ end:
int av_bsf_get_null_filter(AVBSFContext **bsf)
{
#if CONFIG_NULL_BSF
extern const AVBitStreamFilter ff_null_bsf;
return av_bsf_alloc(&ff_null_bsf, bsf);
extern const FFBitStreamFilter ff_null_bsf;
return av_bsf_alloc(&ff_null_bsf.p, bsf);
#else
return av_bsf_alloc(&list_bsf, bsf);
return av_bsf_alloc(&list_bsf.p, bsf);
#endif
}

14
libavcodec/bsf.h
View File

@ -128,20 +128,6 @@ typedef struct AVBitStreamFilter {
* code to this class.
*/
const AVClass *priv_class;
/*****************************************************************
* No fields below this line are part of the public API. They
* may not be used outside of libavcodec and can be changed and
* removed at will.
* New public fields should be added right above.
*****************************************************************
*/
int priv_data_size;
int (*init)(AVBSFContext *ctx);
int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
void (*close)(AVBSFContext *ctx);
void (*flush)(AVBSFContext *ctx);
} AVBitStreamFilter;
/**

13
libavcodec/bsf_internal.h
View File

@ -24,6 +24,19 @@
#include "bsf.h"
#include "packet.h"
typedef struct FFBitStreamFilter {
/**
* The public AVBitStreamFilter. See bsf.h for it.
*/
AVBitStreamFilter p;
int priv_data_size;
int (*init)(AVBSFContext *ctx);
int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
void (*close)(AVBSFContext *ctx);
void (*flush)(AVBSFContext *ctx);
} FFBitStreamFilter;
/**
* Called by the bitstream filters to get the next packet for filtering.
* The filter is responsible for either freeing the packet or passing it to the

6
libavcodec/cbs_bsf.h
View File

@ -67,7 +67,7 @@ typedef struct CBSBSFContext {
*
* Since it calls the update_fragment() function immediately to deal with
* extradata, this should be called after any codec-specific setup is done
* (probably at the end of the AVBitStreamFilter.init function).
* (probably at the end of the FFBitStreamFilter.init function).
*/
int ff_cbs_bsf_generic_init(AVBSFContext *bsf, const CBSBSFType *type);
@ -75,7 +75,7 @@ int ff_cbs_bsf_generic_init(AVBSFContext *bsf, const CBSBSFType *type);
* Close a generic CBS BSF instance.
*
* If no other deinitialisation is required then this function can be used
* directly as AVBitStreamFilter.close.
* directly as FFBitStreamFilter.close.
*/
void ff_cbs_bsf_generic_close(AVBSFContext *bsf);
@ -88,7 +88,7 @@ void ff_cbs_bsf_generic_close(AVBSFContext *bsf);
* the same thing to that new extradata to form the output side-data first.
*
* If the BSF does not do anything else then this function can be used
* directly as AVBitStreamFilter.filter.
* directly as FFBitStreamFilter.filter.
*/
int ff_cbs_bsf_generic_filter(AVBSFContext *bsf, AVPacket *pkt);

4
libavcodec/chomp_bsf.c
View File

@ -39,7 +39,7 @@ static int chomp_filter(AVBSFContext *ctx, AVPacket *pkt)
/**
* This filter removes a string of NULL bytes from the end of a packet.
*/
const AVBitStreamFilter ff_chomp_bsf = {
.name = "chomp",
const FFBitStreamFilter ff_chomp_bsf = {
.p.name = "chomp",
.filter = chomp_filter,
};

8
libavcodec/dca_core_bsf.c
View File

@ -54,8 +54,8 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_DTS, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_dca_core_bsf = {
.name = "dca_core",
.filter = dca_core_filter,
.codec_ids = codec_ids,
const FFBitStreamFilter ff_dca_core_bsf = {
.p.name = "dca_core",
.p.codec_ids = codec_ids,
.filter = dca_core_filter,
};

6
libavcodec/dump_extradata_bsf.c
View File

@ -98,9 +98,9 @@ static const AVClass dump_extradata_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_dump_extradata_bsf = {
.name = "dump_extra",
const FFBitStreamFilter ff_dump_extradata_bsf = {
.p.name = "dump_extra",
.p.priv_class = &dump_extradata_class,
.priv_data_size = sizeof(DumpExtradataContext),
.priv_class = &dump_extradata_class,
.filter = dump_extradata,
};

8
libavcodec/dv_error_marker_bsf.c
View File

@ -128,11 +128,11 @@ static const AVClass dv_error_marker_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_dv_error_marker_bsf = {
.name = "dv_error_marker",
const FFBitStreamFilter ff_dv_error_marker_bsf = {
.p.name = "dv_error_marker",
.p.codec_ids = (const enum AVCodecID []){ AV_CODEC_ID_DVVIDEO, AV_CODEC_ID_NONE },
.p.priv_class = &dv_error_marker_class,
.priv_data_size = sizeof(DVErrorMarkerContext),
.priv_class = &dv_error_marker_class,
.init = dv_error_marker_init,
.filter = dv_error_marker_filter,
.codec_ids = (const enum AVCodecID []){ AV_CODEC_ID_DVVIDEO, AV_CODEC_ID_NONE },
};

8
libavcodec/eac3_core_bsf.c
View File

@ -79,8 +79,8 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_EAC3, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_eac3_core_bsf = {
.name = "eac3_core",
.filter = eac3_core_filter,
.codec_ids = codec_ids,
const FFBitStreamFilter ff_eac3_core_bsf = {
.p.name = "eac3_core",
.p.codec_ids = codec_ids,
.filter = eac3_core_filter,
};

8
libavcodec/extract_extradata_bsf.c
View File

@ -422,11 +422,11 @@ static const AVClass extract_extradata_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_extract_extradata_bsf = {
.name = "extract_extradata",
.codec_ids = codec_ids,
const FFBitStreamFilter ff_extract_extradata_bsf = {
.p.name = "extract_extradata",
.p.codec_ids = codec_ids,
.p.priv_class = &extract_extradata_class,
.priv_data_size = sizeof(ExtractExtradataContext),
.priv_class = &extract_extradata_class,
.init = extract_extradata_init,
.filter = extract_extradata_filter,
.close = extract_extradata_close,

8
libavcodec/filter_units_bsf.c
View File

@ -235,12 +235,12 @@ static const AVClass filter_units_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_filter_units_bsf = {
.name = "filter_units",
const FFBitStreamFilter ff_filter_units_bsf = {
.p.name = "filter_units",
.p.codec_ids = ff_cbs_all_codec_ids,
.p.priv_class = &filter_units_class,
.priv_data_size = sizeof(FilterUnitsContext),
.priv_class = &filter_units_class,
.init = &filter_units_init,
.close = &filter_units_close,
.filter = &filter_units_filter,
.codec_ids = ff_cbs_all_codec_ids,
};

9
libavcodec/h264_metadata_bsf.c
View File

@ -22,6 +22,7 @@
#include "libavutil/opt.h"
#include "bsf.h"
#include "bsf_internal.h"
#include "cbs.h"
#include "cbs_bsf.h"
#include "cbs_h264.h"
@ -716,12 +717,12 @@ static const enum AVCodecID h264_metadata_codec_ids[] = {
AV_CODEC_ID_H264, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_h264_metadata_bsf = {
.name = "h264_metadata",
const FFBitStreamFilter ff_h264_metadata_bsf = {
.p.name = "h264_metadata",
.p.codec_ids = h264_metadata_codec_ids,
.p.priv_class = &h264_metadata_class,
.priv_data_size = sizeof(H264MetadataContext),
.priv_class = &h264_metadata_class,
.init = &h264_metadata_init,
.close = &ff_cbs_bsf_generic_close,
.filter = &ff_cbs_bsf_generic_filter,
.codec_ids = h264_metadata_codec_ids,
};

6
libavcodec/h264_mp4toannexb_bsf.c
View File

@ -312,11 +312,11 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_H264, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_h264_mp4toannexb_bsf = {
.name = "h264_mp4toannexb",
const FFBitStreamFilter ff_h264_mp4toannexb_bsf = {
.p.name = "h264_mp4toannexb",
.p.codec_ids = codec_ids,
.priv_data_size = sizeof(H264BSFContext),
.init = h264_mp4toannexb_init,
.filter = h264_mp4toannexb_filter,
.flush = h264_mp4toannexb_flush,
.codec_ids = codec_ids,
};

7
libavcodec/h264_redundant_pps_bsf.c
View File

@ -21,6 +21,7 @@
#include "libavutil/log.h"
#include "bsf.h"
#include "bsf_internal.h"
#include "cbs.h"
#include "cbs_bsf.h"
#include "cbs_h264.h"
@ -126,11 +127,11 @@ static const enum AVCodecID h264_redundant_pps_codec_ids[] = {
AV_CODEC_ID_H264, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_h264_redundant_pps_bsf = {
.name = "h264_redundant_pps",
const FFBitStreamFilter ff_h264_redundant_pps_bsf = {
.p.name = "h264_redundant_pps",
.p.codec_ids = h264_redundant_pps_codec_ids,
.priv_data_size = sizeof(H264RedundantPPSContext),
.init = &h264_redundant_pps_init,
.close = &ff_cbs_bsf_generic_close,
.filter = &ff_cbs_bsf_generic_filter,
.codec_ids = h264_redundant_pps_codec_ids,
};

9
libavcodec/h265_metadata_bsf.c
View File

@ -20,6 +20,7 @@
#include "libavutil/opt.h"
#include "bsf.h"
#include "bsf_internal.h"
#include "cbs.h"
#include "cbs_bsf.h"
#include "cbs_h265.h"
@ -498,12 +499,12 @@ static const enum AVCodecID h265_metadata_codec_ids[] = {
AV_CODEC_ID_HEVC, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_hevc_metadata_bsf = {
.name = "hevc_metadata",
const FFBitStreamFilter ff_hevc_metadata_bsf = {
.p.name = "hevc_metadata",
.p.codec_ids = h265_metadata_codec_ids,
.p.priv_class = &h265_metadata_class,
.priv_data_size = sizeof(H265MetadataContext),
.priv_class = &h265_metadata_class,
.init = &h265_metadata_init,
.close = &ff_cbs_bsf_generic_close,
.filter = &ff_cbs_bsf_generic_filter,
.codec_ids = h265_metadata_codec_ids,
};

10
libavcodec/hapqa_extract_bsf.c
View File

@ -125,10 +125,10 @@ static const AVClass hapqa_extract_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_hapqa_extract_bsf = {
.name = "hapqa_extract",
.filter = hapqa_extract,
const FFBitStreamFilter ff_hapqa_extract_bsf = {
.p.name = "hapqa_extract",
.p.codec_ids = codec_ids,
.p.priv_class = &hapqa_extract_class,
.priv_data_size = sizeof(HapqaExtractContext),
.priv_class = &hapqa_extract_class,
.codec_ids = codec_ids,
.filter = hapqa_extract,
};

6
libavcodec/hevc_mp4toannexb_bsf.c
View File

@ -195,10 +195,10 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_HEVC, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_hevc_mp4toannexb_bsf = {
.name = "hevc_mp4toannexb",
const FFBitStreamFilter ff_hevc_mp4toannexb_bsf = {
.p.name = "hevc_mp4toannexb",
.p.codec_ids = codec_ids,
.priv_data_size = sizeof(HEVCBSFContext),
.init = hevc_mp4toannexb_init,
.filter = hevc_mp4toannexb_filter,
.codec_ids = codec_ids,
};

8
libavcodec/imx_dump_header_bsf.c
View File

@ -69,8 +69,8 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_MPEG2VIDEO, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_imx_dump_header_bsf = {
.name = "imxdump",
.filter = imx_dump_header,
.codec_ids = codec_ids,
const FFBitStreamFilter ff_imx_dump_header_bsf = {
.p.name = "imxdump",
.p.codec_ids = codec_ids,
.filter = imx_dump_header,
};

6
libavcodec/mjpeg2jpeg_bsf.c
View File

@ -135,8 +135,8 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_MJPEG, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_mjpeg2jpeg_bsf = {
.name = "mjpeg2jpeg",
const FFBitStreamFilter ff_mjpeg2jpeg_bsf = {
.p.name = "mjpeg2jpeg",
.p.codec_ids = codec_ids,
.filter = mjpeg2jpeg_filter,
.codec_ids = codec_ids,
};

8
libavcodec/mjpega_dump_header_bsf.c
View File

@ -101,8 +101,8 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_MJPEG, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_mjpega_dump_header_bsf = {
.name = "mjpegadump",
.filter = mjpega_dump_header,
.codec_ids = codec_ids,
const FFBitStreamFilter ff_mjpega_dump_header_bsf = {
.p.name = "mjpegadump",
.p.codec_ids = codec_ids,
.filter = mjpega_dump_header,
};

8
libavcodec/movsub_bsf.c
View File

@ -57,8 +57,8 @@ fail:
return ret;
}
const AVBitStreamFilter ff_text2movsub_bsf = {
.name = "text2movsub",
const FFBitStreamFilter ff_text2movsub_bsf = {
.p.name = "text2movsub",
.filter = text2movsub,
};
@ -81,7 +81,7 @@ static int mov2textsub(AVBSFContext *ctx, AVPacket *pkt)
return 0;
}
const AVBitStreamFilter ff_mov2textsub_bsf = {
.name = "mov2textsub",
const FFBitStreamFilter ff_mov2textsub_bsf = {
.p.name = "mov2textsub",
.filter = mov2textsub,
};

8
libavcodec/mp3_header_decompress_bsf.c
View File

@ -123,8 +123,8 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_MP3, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_mp3_header_decompress_bsf = {
.name = "mp3decomp",
.filter = mp3_header_decompress,
.codec_ids = codec_ids,
const FFBitStreamFilter ff_mp3_header_decompress_bsf = {
.p.name = "mp3decomp",
.p.codec_ids = codec_ids,
.filter = mp3_header_decompress,
};

10
libavcodec/mpeg2_metadata_bsf.c
View File

@ -16,11 +16,11 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libavutil/avstring.h"
#include "libavutil/common.h"
#include "libavutil/opt.h"
#include "bsf.h"
#include "bsf_internal.h"
#include "cbs.h"
#include "cbs_bsf.h"
#include "cbs_mpeg2.h"
@ -232,12 +232,12 @@ static const enum AVCodecID mpeg2_metadata_codec_ids[] = {
AV_CODEC_ID_MPEG2VIDEO, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_mpeg2_metadata_bsf = {
.name = "mpeg2_metadata",
const FFBitStreamFilter ff_mpeg2_metadata_bsf = {
.p.name = "mpeg2_metadata",
.p.codec_ids = mpeg2_metadata_codec_ids,
.p.priv_class = &mpeg2_metadata_class,
.priv_data_size = sizeof(MPEG2MetadataContext),
.priv_class = &mpeg2_metadata_class,
.init = &mpeg2_metadata_init,
.close = &ff_cbs_bsf_generic_close,
.filter = &ff_cbs_bsf_generic_filter,
.codec_ids = mpeg2_metadata_codec_ids,
};

6
libavcodec/mpeg4_unpack_bframes_bsf.c
View File

@ -155,12 +155,12 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_MPEG4, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_mpeg4_unpack_bframes_bsf = {
.name = "mpeg4_unpack_bframes",
const FFBitStreamFilter ff_mpeg4_unpack_bframes_bsf = {
.p.name = "mpeg4_unpack_bframes",
.p.codec_ids = codec_ids,
.priv_data_size = sizeof(UnpackBFramesBSFContext),
.init = mpeg4_unpack_bframes_init,
.filter = mpeg4_unpack_bframes_filter,
.flush = mpeg4_unpack_bframes_close_flush,
.close = mpeg4_unpack_bframes_close_flush,
.codec_ids = codec_ids,
};

7
libavcodec/noise_bsf.c
View File

@ -23,7 +23,6 @@
#include "bsf.h"
#include "bsf_internal.h"
#include "libavutil/avstring.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/eval.h"
@ -220,10 +219,10 @@ static const AVClass noise_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_noise_bsf = {
.name = "noise",
const FFBitStreamFilter ff_noise_bsf = {
.p.name = "noise",
.p.priv_class = &noise_class,
.priv_data_size = sizeof(NoiseContext),
.priv_class = &noise_class,
.init = noise_init,
.close = noise_close,
.filter = noise,

5
libavcodec/null_bsf.c
View File

@ -21,10 +21,9 @@
* Null bitstream filter -- pass the input through unchanged.
*/
#include "bsf.h"
#include "bsf_internal.h"
const AVBitStreamFilter ff_null_bsf = {
.name = "null",
const FFBitStreamFilter ff_null_bsf = {
.p.name = "null",
.filter = ff_bsf_get_packet_ref,
};

8
libavcodec/opus_metadata_bsf.c
View File

@ -58,11 +58,11 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_OPUS, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_opus_metadata_bsf = {
.name = "opus_metadata",
const FFBitStreamFilter ff_opus_metadata_bsf = {
.p.name = "opus_metadata",
.p.codec_ids = codec_ids,
.p.priv_class = &opus_metadata_class,
.priv_data_size = sizeof(OpusBSFContext),
.priv_class = &opus_metadata_class,
.init = &opus_metadata_init,
.filter = &ff_bsf_get_packet_ref,
.codec_ids = codec_ids,
};

8
libavcodec/pcm_rechunk_bsf.c
View File

@ -209,13 +209,13 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_pcm_rechunk_bsf = {
.name = "pcm_rechunk",
const FFBitStreamFilter ff_pcm_rechunk_bsf = {
.p.name = "pcm_rechunk",
.p.codec_ids = codec_ids,
.p.priv_class = &pcm_rechunk_class,
.priv_data_size = sizeof(PCMContext),
.priv_class = &pcm_rechunk_class,
.filter = rechunk_filter,
.init = init,
.flush = flush,
.close = uninit,
.codec_ids = codec_ids,
};

12
libavcodec/prores_metadata_bsf.c
View File

@ -166,11 +166,11 @@ static const AVClass prores_metadata_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_prores_metadata_bsf = {
.name = "prores_metadata",
.init = prores_metadata_init,
.filter = prores_metadata,
const FFBitStreamFilter ff_prores_metadata_bsf = {
.p.name = "prores_metadata",
.p.codec_ids = codec_ids,
.p.priv_class = &prores_metadata_class,
.priv_data_size = sizeof(ProresMetadataContext),
.priv_class = &prores_metadata_class,
.codec_ids = codec_ids,
.init = prores_metadata_init,
.filter = prores_metadata,
};

6
libavcodec/remove_extradata_bsf.c
View File

@ -245,9 +245,9 @@ static const AVClass remove_extradata_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_remove_extradata_bsf = {
.name = "remove_extra",
const FFBitStreamFilter ff_remove_extradata_bsf = {
.p.name = "remove_extra",
.p.priv_class = &remove_extradata_class,
.priv_data_size = sizeof(RemoveExtradataContext),
.priv_class = &remove_extradata_class,
.filter = remove_extradata,
};

6
libavcodec/setts_bsf.c
View File

@ -267,10 +267,10 @@ static const AVClass setts_class = {
.version = LIBAVUTIL_VERSION_INT,
};
const AVBitStreamFilter ff_setts_bsf = {
.name = "setts",
const FFBitStreamFilter ff_setts_bsf = {
.p.name = "setts",
.p.priv_class = &setts_class,
.priv_data_size = sizeof(SetTSContext),
.priv_class = &setts_class,
.init = setts_init,
.close = setts_close,
.filter = setts_filter,

6
libavcodec/trace_headers_bsf.c
View File

@ -117,11 +117,11 @@ static int trace_headers(AVBSFContext *bsf, AVPacket *pkt)
return err;
}
const AVBitStreamFilter ff_trace_headers_bsf = {
.name = "trace_headers",
const FFBitStreamFilter ff_trace_headers_bsf = {
.p.name = "trace_headers",
.p.codec_ids = ff_cbs_all_codec_ids,
.priv_data_size = sizeof(TraceHeadersContext),
.init = &trace_headers_init,
.close = &trace_headers_close,
.filter = &trace_headers,
.codec_ids = ff_cbs_all_codec_ids,
};

6
libavcodec/truehd_core_bsf.c
View File

@ -173,10 +173,10 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_TRUEHD, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_truehd_core_bsf = {
.name = "truehd_core",
const FFBitStreamFilter ff_truehd_core_bsf = {
.p.name = "truehd_core",
.p.codec_ids = codec_ids,
.priv_data_size = sizeof(TrueHDCoreContext),
.filter = truehd_core_filter,
.flush = truehd_core_flush,
.codec_ids = codec_ids,
};

12
libavcodec/vp9_metadata_bsf.c
View File

@ -16,11 +16,11 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libavutil/avstring.h"
#include "libavutil/common.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "bsf.h"
#include "bsf_internal.h"
#include "cbs.h"
#include "cbs_bsf.h"
#include "cbs_vp9.h"
@ -135,12 +135,12 @@ static const enum AVCodecID vp9_metadata_codec_ids[] = {
AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_vp9_metadata_bsf = {
.name = "vp9_metadata",
const FFBitStreamFilter ff_vp9_metadata_bsf = {
.p.name = "vp9_metadata",
.p.codec_ids = vp9_metadata_codec_ids,
.p.priv_class = &vp9_metadata_class,
.priv_data_size = sizeof(VP9MetadataContext),
.priv_class = &vp9_metadata_class,
.init = &vp9_metadata_init,
.close = &ff_cbs_bsf_generic_close,
.filter = &ff_cbs_bsf_generic_filter,
.codec_ids = vp9_metadata_codec_ids,
};

6
libavcodec/vp9_raw_reorder_bsf.c
View File

@ -408,11 +408,11 @@ static const enum AVCodecID vp9_raw_reorder_codec_ids[] = {
AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_vp9_raw_reorder_bsf = {
.name = "vp9_raw_reorder",
const FFBitStreamFilter ff_vp9_raw_reorder_bsf = {
.p.name = "vp9_raw_reorder",
.p.codec_ids = vp9_raw_reorder_codec_ids,
.priv_data_size = sizeof(VP9RawReorderContext),
.close = &vp9_raw_reorder_close,
.flush = &vp9_raw_reorder_flush,
.filter = &vp9_raw_reorder_filter,
.codec_ids = vp9_raw_reorder_codec_ids,
};

6
libavcodec/vp9_superframe_bsf.c
View File

@ -211,12 +211,12 @@ static const enum AVCodecID codec_ids[] = {
AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
};
const AVBitStreamFilter ff_vp9_superframe_bsf = {
.name = "vp9_superframe",
const FFBitStreamFilter ff_vp9_superframe_bsf = {
.p.name = "vp9_superframe",
.p.codec_ids = codec_ids,
.priv_data_size = sizeof(VP9BSFContext),
.filter = vp9_superframe_filter,
.init = vp9_superframe_init,
.flush = vp9_superframe_flush,
.close = vp9_superframe_close,
.codec_ids = codec_ids,
};

6
libavcodec/vp9_superframe_split_bsf.c
View File

@ -155,12 +155,12 @@ static void vp9_superframe_split_uninit(AVBSFContext *ctx)
av_packet_free(&s->buffer_pkt);
}
const AVBitStreamFilter ff_vp9_superframe_split_bsf = {
.name = "vp9_superframe_split",
const FFBitStreamFilter ff_vp9_superframe_split_bsf = {
.p.name = "vp9_superframe_split",
.p.codec_ids = (const enum AVCodecID []){ AV_CODEC_ID_VP9, AV_CODEC_ID_NONE },
.priv_data_size = sizeof(VP9SFSplitContext),
.init = vp9_superframe_split_init,
.flush = vp9_superframe_split_flush,
.close = vp9_superframe_split_uninit,
.filter = vp9_superframe_split_filter,
.codec_ids = (const enum AVCodecID []){ AV_CODEC_ID_VP9, AV_CODEC_ID_NONE },
};