1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <string.h>
20
21 #include "libavutil/common.h"
22 #include "libavutil/mem.h"
23
24 #include "bsf.h"
25 #include "cbs.h"
26 #include "cbs_h264.h"
27 #include "h264.h"
28
29
30 typedef struct H264RedundantPPSContext {
31 CodedBitstreamContext *input;
32 CodedBitstreamContext *output;
33
34 CodedBitstreamFragment access_unit;
35
36 int global_pic_init_qp;
37 int current_pic_init_qp;
38 int extradata_pic_init_qp;
39 } H264RedundantPPSContext;
40
41
h264_redundant_pps_fixup_pps(H264RedundantPPSContext * ctx,H264RawPPS * pps)42 static int h264_redundant_pps_fixup_pps(H264RedundantPPSContext *ctx,
43 H264RawPPS *pps)
44 {
45 // Record the current value of pic_init_qp in order to fix up
46 // following slices, then overwrite with the global value.
47 ctx->current_pic_init_qp = pps->pic_init_qp_minus26 + 26;
48 pps->pic_init_qp_minus26 = ctx->global_pic_init_qp - 26;
49
50 // Some PPSs have this set, so it must be set in all of them.
51 // (Slices which do not use such a PPS on input will still have
52 // *_weight_l*flag as zero and therefore write equivalently.)
53 pps->weighted_pred_flag = 1;
54
55 return 0;
56 }
57
h264_redundant_pps_fixup_slice(H264RedundantPPSContext * ctx,H264RawSliceHeader * slice)58 static int h264_redundant_pps_fixup_slice(H264RedundantPPSContext *ctx,
59 H264RawSliceHeader *slice)
60 {
61 int qp;
62
63 qp = ctx->current_pic_init_qp + slice->slice_qp_delta;
64 slice->slice_qp_delta = qp - ctx->global_pic_init_qp;
65
66 return 0;
67 }
68
h264_redundant_pps_filter(AVBSFContext * bsf,AVPacket * out)69 static int h264_redundant_pps_filter(AVBSFContext *bsf, AVPacket *out)
70 {
71 H264RedundantPPSContext *ctx = bsf->priv_data;
72 AVPacket *in;
73 CodedBitstreamFragment *au = &ctx->access_unit;
74 int au_has_sps;
75 int err, i;
76
77 err = ff_bsf_get_packet(bsf, &in);
78 if (err < 0)
79 return err;
80
81 err = ff_cbs_read_packet(ctx->input, au, in);
82 if (err < 0)
83 return err;
84
85 au_has_sps = 0;
86 for (i = 0; i < au->nb_units; i++) {
87 CodedBitstreamUnit *nal = &au->units[i];
88
89 if (nal->type == H264_NAL_SPS)
90 au_has_sps = 1;
91 if (nal->type == H264_NAL_PPS) {
92 h264_redundant_pps_fixup_pps(ctx, nal->content);
93 if (!au_has_sps) {
94 av_log(bsf, AV_LOG_VERBOSE, "Deleting redundant PPS "
95 "at %"PRId64".\n", in->pts);
96 ff_cbs_delete_unit(ctx->input, au, i);
97 }
98 }
99 if (nal->type == H264_NAL_SLICE ||
100 nal->type == H264_NAL_IDR_SLICE) {
101 H264RawSlice *slice = nal->content;
102 h264_redundant_pps_fixup_slice(ctx, &slice->header);
103 }
104 }
105
106 err = ff_cbs_write_packet(ctx->output, out, au);
107 if (err < 0)
108 return err;
109
110 ff_cbs_fragment_uninit(ctx->output, au);
111
112 err = av_packet_copy_props(out, in);
113 if (err < 0)
114 return err;
115
116 av_packet_free(&in);
117
118 return 0;
119 }
120
h264_redundant_pps_init(AVBSFContext * bsf)121 static int h264_redundant_pps_init(AVBSFContext *bsf)
122 {
123 H264RedundantPPSContext *ctx = bsf->priv_data;
124 CodedBitstreamFragment *au = &ctx->access_unit;
125 int err, i;
126
127 err = ff_cbs_init(&ctx->input, AV_CODEC_ID_H264, bsf);
128 if (err < 0)
129 return err;
130
131 err = ff_cbs_init(&ctx->output, AV_CODEC_ID_H264, bsf);
132 if (err < 0)
133 return err;
134
135 ctx->global_pic_init_qp = 26;
136
137 if (bsf->par_in->extradata) {
138 err = ff_cbs_read_extradata(ctx->input, au, bsf->par_in);
139 if (err < 0) {
140 av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
141 return err;
142 }
143
144 for (i = 0; i < au->nb_units; i++) {
145 if (au->units[i].type == H264_NAL_PPS)
146 h264_redundant_pps_fixup_pps(ctx, au->units[i].content);
147 }
148
149 ctx->extradata_pic_init_qp = ctx->current_pic_init_qp;
150 err = ff_cbs_write_extradata(ctx->output, bsf->par_out, au);
151 if (err < 0) {
152 av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
153 return err;
154 }
155
156 ff_cbs_fragment_uninit(ctx->output, au);
157 }
158
159 return 0;
160 }
161
h264_redundant_pps_flush(AVBSFContext * bsf)162 static void h264_redundant_pps_flush(AVBSFContext *bsf)
163 {
164 H264RedundantPPSContext *ctx = bsf->priv_data;
165 ctx->current_pic_init_qp = ctx->extradata_pic_init_qp;
166 }
167
h264_redundant_pps_close(AVBSFContext * bsf)168 static void h264_redundant_pps_close(AVBSFContext *bsf)
169 {
170 H264RedundantPPSContext *ctx = bsf->priv_data;
171 ff_cbs_close(&ctx->input);
172 ff_cbs_close(&ctx->output);
173 }
174
175 static const enum AVCodecID h264_redundant_pps_codec_ids[] = {
176 AV_CODEC_ID_H264, AV_CODEC_ID_NONE,
177 };
178
179 const AVBitStreamFilter ff_h264_redundant_pps_bsf = {
180 .name = "h264_redundant_pps",
181 .priv_data_size = sizeof(H264RedundantPPSContext),
182 .init = &h264_redundant_pps_init,
183 .flush = &h264_redundant_pps_flush,
184 .close = &h264_redundant_pps_close,
185 .filter = &h264_redundant_pps_filter,
186 .codec_ids = h264_redundant_pps_codec_ids,
187 };
188