virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-01-13 21:28:01 +02:00
Code Issues Releases Activity

h264_redundant_pps_bsf: Use common cbs bsf implementation

Browse Source
This commit is contained in:
Mark Thompson 2021-01-01 21:35:23 +00:00
parent 375176a540
commit fa75e43875
1 changed files with 21 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
libavcodec/h264_redundant_pps_bsf.c
View File

@ -24,15 +24,13 @@
#include "bsf.h" #include "bsf.h"
#include "bsf_internal.h" #include "bsf_internal.h"
#include "cbs.h" #include "cbs.h"
#include "cbs_bsf.h"
#include "cbs_h264.h" #include "cbs_h264.h"
#include "h264.h" #include "h264.h"
typedef struct H264RedundantPPSContext { typedef struct H264RedundantPPSContext {
CodedBitstreamContext *input; CBSBSFContext common;
CodedBitstreamContext *output;
CodedBitstreamFragment access_unit;
int global_pic_init_qp; int global_pic_init_qp;
int current_pic_init_qp; int current_pic_init_qp;
@ -49,7 +47,7 @@ static int h264_redundant_pps_fixup_pps(H264RedundantPPSContext *ctx,
// The changes we are about to perform affect the parsing process, // The changes we are about to perform affect the parsing process,
// so we must make sure that the PPS is writable, otherwise the // so we must make sure that the PPS is writable, otherwise the
// parsing of future slices will be incorrect and even raise errors. // parsing of future slices will be incorrect and even raise errors.
err = ff_cbs_make_unit_writable(ctx->input, unit); err = ff_cbs_make_unit_writable(ctx->common.input, unit);
if (err < 0) if (err < 0)
return err; return err;
pps = unit->content; pps = unit->content;
@ -78,21 +76,14 @@ static int h264_redundant_pps_fixup_slice(H264RedundantPPSContext *ctx,
return 0; return 0;
} }
static int h264_redundant_pps_filter(AVBSFContext *bsf, AVPacket *pkt) static int h264_redundant_pps_update_fragment(AVBSFContext *bsf,
AVPacket *pkt,
CodedBitstreamFragment *au)
{ {
H264RedundantPPSContext *ctx = bsf->priv_data; H264RedundantPPSContext *ctx = bsf->priv_data;
CodedBitstreamFragment *au = &ctx->access_unit;
int au_has_sps; int au_has_sps;
int err, i; int err, i;
err = ff_bsf_get_packet_ref(bsf, pkt);
if (err < 0)
return err;
err = ff_cbs_read_packet(ctx->input, au, pkt);
if (err < 0)
goto fail;
au_has_sps = 0; au_has_sps = 0;
for (i = 0; i < au->nb_units; i++) { for (i = 0; i < au->nb_units; i++) {
CodedBitstreamUnit *nal = &au->units[i]; CodedBitstreamUnit *nal = &au->units[i];
@ -102,7 +93,7 @@ static int h264_redundant_pps_filter(AVBSFContext *bsf, AVPacket *pkt)
if (nal->type == H264_NAL_PPS) { if (nal->type == H264_NAL_PPS) {
err = h264_redundant_pps_fixup_pps(ctx, nal); err = h264_redundant_pps_fixup_pps(ctx, nal);
if (err < 0) if (err < 0)
goto fail; return err;
if (!au_has_sps) { if (!au_has_sps) {
av_log(bsf, AV_LOG_VERBOSE, "Deleting redundant PPS " av_log(bsf, AV_LOG_VERBOSE, "Deleting redundant PPS "
"at %"PRId64".\n", pkt->pts); "at %"PRId64".\n", pkt->pts);
@ -118,62 +109,7 @@ static int h264_redundant_pps_filter(AVBSFContext *bsf, AVPacket *pkt)
} }
} }
err = ff_cbs_write_packet(ctx->output, pkt, au); return 0;
if (err < 0)
goto fail;
err = 0;
fail:
ff_cbs_fragment_reset(au);
if (err < 0)
av_packet_unref(pkt);
return err;
}
static int h264_redundant_pps_init(AVBSFContext *bsf)
{
H264RedundantPPSContext *ctx = bsf->priv_data;
CodedBitstreamFragment *au = &ctx->access_unit;
int err, i;
err = ff_cbs_init(&ctx->input, AV_CODEC_ID_H264, bsf);
if (err < 0)
return err;
err = ff_cbs_init(&ctx->output, AV_CODEC_ID_H264, bsf);
if (err < 0)
return err;
ctx->global_pic_init_qp = 26;
if (bsf->par_in->extradata) {
err = ff_cbs_read_extradata(ctx->input, au, bsf->par_in);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
goto fail;
}
for (i = 0; i < au->nb_units; i++) {
if (au->units[i].type == H264_NAL_PPS) {
err = h264_redundant_pps_fixup_pps(ctx, &au->units[i]);
if (err < 0)
goto fail;
}
}
ctx->extradata_pic_init_qp = ctx->current_pic_init_qp;
err = ff_cbs_write_extradata(ctx->output, bsf->par_out, au);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
goto fail;
}
}
err = 0;
fail:
ff_cbs_fragment_reset(au);
return err;
} }
static void h264_redundant_pps_flush(AVBSFContext *bsf) static void h264_redundant_pps_flush(AVBSFContext *bsf)
@ -182,13 +118,20 @@ static void h264_redundant_pps_flush(AVBSFContext *bsf)
ctx->current_pic_init_qp = ctx->extradata_pic_init_qp; ctx->current_pic_init_qp = ctx->extradata_pic_init_qp;
} }
static void h264_redundant_pps_close(AVBSFContext *bsf) static const CBSBSFType h264_redundant_pps_type = {
.codec_id = AV_CODEC_ID_H264,
.fragment_name = "access unit",
.unit_name = "NAL unit",
.update_fragment = &h264_redundant_pps_update_fragment,
};
static int h264_redundant_pps_init(AVBSFContext *bsf)
{ {
H264RedundantPPSContext *ctx = bsf->priv_data; H264RedundantPPSContext *ctx = bsf->priv_data;
ff_cbs_fragment_free(&ctx->access_unit); ctx->global_pic_init_qp = 26;
ff_cbs_close(&ctx->input);
ff_cbs_close(&ctx->output); return ff_cbs_bsf_generic_init(bsf, &h264_redundant_pps_type);
} }
static const enum AVCodecID h264_redundant_pps_codec_ids[] = { static const enum AVCodecID h264_redundant_pps_codec_ids[] = {
@ -200,7 +143,7 @@ const AVBitStreamFilter ff_h264_redundant_pps_bsf = {
.priv_data_size = sizeof(H264RedundantPPSContext), .priv_data_size = sizeof(H264RedundantPPSContext),
.init = &h264_redundant_pps_init, .init = &h264_redundant_pps_init,
.flush = &h264_redundant_pps_flush, .flush = &h264_redundant_pps_flush,
.close = &h264_redundant_pps_close, .close = &ff_cbs_bsf_generic_close,
.filter = &h264_redundant_pps_filter, .filter = &ff_cbs_bsf_generic_filter,
.codec_ids = h264_redundant_pps_codec_ids, .codec_ids = h264_redundant_pps_codec_ids,
}; };