Line |
Branch |
Exec |
Source |
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 "libavutil/common.h" |
20 |
|
|
#include "libavutil/mem.h" |
21 |
|
|
#include "libavutil/opt.h" |
22 |
|
|
|
23 |
|
|
#include "bsf.h" |
24 |
|
|
#include "bsf_internal.h" |
25 |
|
|
#include "cbs.h" |
26 |
|
|
#include "cbs_bsf.h" |
27 |
|
|
#include "cbs_av1.h" |
28 |
|
|
#include "cbs_h265.h" |
29 |
|
|
#include "dovi_rpu.h" |
30 |
|
|
#include "h2645data.h" |
31 |
|
|
#include "h265_profile_level.h" |
32 |
|
|
#include "itut35.h" |
33 |
|
|
|
34 |
|
|
#include "hevc/hevc.h" |
35 |
|
|
|
36 |
|
|
typedef struct DoviRpuContext { |
37 |
|
|
CBSBSFContext common; |
38 |
|
|
DOVIContext dec; |
39 |
|
|
DOVIContext enc; |
40 |
|
|
|
41 |
|
|
int strip; |
42 |
|
|
int compression; |
43 |
|
|
} DoviRpuContext; |
44 |
|
|
|
45 |
|
✗ |
static int update_rpu(AVBSFContext *bsf, const AVPacket *pkt, int flags, |
46 |
|
|
const uint8_t *rpu, size_t rpu_size, |
47 |
|
|
uint8_t **out_rpu, int *out_size) |
48 |
|
|
{ |
49 |
|
✗ |
DoviRpuContext *s = bsf->priv_data; |
50 |
|
✗ |
AVDOVIMetadata *metadata = NULL; |
51 |
|
|
int ret; |
52 |
|
|
|
53 |
|
✗ |
ret = ff_dovi_rpu_parse(&s->dec, rpu, rpu_size, 0); |
54 |
|
✗ |
if (ret < 0) { |
55 |
|
✗ |
ff_dovi_ctx_flush(&s->dec); |
56 |
|
✗ |
return ret; |
57 |
|
|
} |
58 |
|
|
|
59 |
|
✗ |
ret = ff_dovi_get_metadata(&s->dec, &metadata); |
60 |
|
✗ |
if (ret == 0 /* no metadata */) { |
61 |
|
✗ |
*out_rpu = NULL; |
62 |
|
✗ |
*out_size = 0; |
63 |
|
✗ |
return 0; |
64 |
|
✗ |
} else if (ret < 0) { |
65 |
|
✗ |
ff_dovi_ctx_flush(&s->dec); |
66 |
|
✗ |
return ret; |
67 |
|
|
} |
68 |
|
|
|
69 |
|
✗ |
if (pkt && !(pkt->flags & AV_PKT_FLAG_KEY)) |
70 |
|
✗ |
flags |= FF_DOVI_COMPRESS_RPU; |
71 |
|
✗ |
ret = ff_dovi_rpu_generate(&s->enc, metadata, flags, out_rpu, out_size); |
72 |
|
✗ |
av_free(metadata); |
73 |
|
✗ |
if (ret < 0) |
74 |
|
✗ |
ff_dovi_ctx_flush(&s->enc); |
75 |
|
|
|
76 |
|
✗ |
return ret; |
77 |
|
|
} |
78 |
|
|
|
79 |
|
✗ |
static int dovi_rpu_update_fragment_hevc(AVBSFContext *bsf, AVPacket *pkt, |
80 |
|
|
CodedBitstreamFragment *au) |
81 |
|
|
{ |
82 |
|
✗ |
DoviRpuContext *s = bsf->priv_data; |
83 |
|
✗ |
CodedBitstreamUnit *nal = au->nb_units ? &au->units[au->nb_units - 1] : NULL; |
84 |
|
✗ |
uint8_t *rpu = NULL; |
85 |
|
|
int rpu_size, ret; |
86 |
|
|
|
87 |
|
|
// HEVC_NAL_UNSPEC62 is Dolby Vision PRU and HEVC_NAL_UNSPEC63 is Dolby Vision EL |
88 |
|
✗ |
if (!nal || (nal->type != HEVC_NAL_UNSPEC62 && nal->type != HEVC_NAL_UNSPEC63)) |
89 |
|
✗ |
return 0; |
90 |
|
|
|
91 |
|
✗ |
if (s->strip) { |
92 |
|
✗ |
ff_cbs_delete_unit(au, au->nb_units - 1); |
93 |
|
✗ |
return 0; |
94 |
|
|
} |
95 |
|
|
|
96 |
|
✗ |
if (nal->type == HEVC_NAL_UNSPEC63) |
97 |
|
✗ |
return 0; |
98 |
|
|
|
99 |
|
✗ |
ret = update_rpu(bsf, pkt, 0, nal->data + 2, nal->data_size - 2, &rpu, &rpu_size); |
100 |
|
✗ |
if (ret < 0) |
101 |
|
✗ |
return ret; |
102 |
|
|
|
103 |
|
|
/* NAL unit header + NAL prefix */ |
104 |
|
✗ |
if (rpu_size + 3 <= nal->data_size && av_buffer_is_writable(nal->data_ref)) { |
105 |
|
✗ |
memcpy(nal->data + 3, rpu, rpu_size); |
106 |
|
✗ |
av_free(rpu); |
107 |
|
✗ |
nal->data_size = rpu_size + 3; |
108 |
|
|
} else { |
109 |
|
✗ |
AVBufferRef *ref = av_buffer_alloc(rpu_size + 3); |
110 |
|
✗ |
if (!ref) { |
111 |
|
✗ |
av_free(rpu); |
112 |
|
✗ |
return AVERROR(ENOMEM); |
113 |
|
|
} |
114 |
|
|
|
115 |
|
✗ |
memcpy(ref->data, nal->data, 3); |
116 |
|
✗ |
memcpy(ref->data + 3, rpu, rpu_size); |
117 |
|
✗ |
av_buffer_unref(&nal->data_ref); |
118 |
|
✗ |
av_free(rpu); |
119 |
|
✗ |
nal->data = ref->data; |
120 |
|
✗ |
nal->data_size = rpu_size + 3; |
121 |
|
✗ |
nal->data_ref = ref; |
122 |
|
✗ |
nal->data_bit_padding = 0; |
123 |
|
|
} |
124 |
|
|
|
125 |
|
✗ |
return 0; |
126 |
|
|
} |
127 |
|
|
|
128 |
|
✗ |
static int dovi_rpu_update_fragment_av1(AVBSFContext *bsf, AVPacket *pkt, |
129 |
|
|
CodedBitstreamFragment *frag) |
130 |
|
|
{ |
131 |
|
✗ |
DoviRpuContext *s = bsf->priv_data; |
132 |
|
|
int provider_code, provider_oriented_code, rpu_size, ret; |
133 |
|
|
AVBufferRef *ref; |
134 |
|
|
uint8_t *rpu; |
135 |
|
|
|
136 |
|
✗ |
for (int i = 0; i < frag->nb_units; i++) { |
137 |
|
✗ |
AV1RawOBU *obu = frag->units[i].content; |
138 |
|
✗ |
AV1RawMetadataITUTT35 *t35 = &obu->obu.metadata.metadata.itut_t35; |
139 |
|
✗ |
if (frag->units[i].type != AV1_OBU_METADATA || |
140 |
|
✗ |
obu->obu.metadata.metadata_type != AV1_METADATA_TYPE_ITUT_T35 || |
141 |
|
✗ |
t35->itu_t_t35_country_code != ITU_T_T35_COUNTRY_CODE_US || |
142 |
|
✗ |
t35->payload_size < 6) |
143 |
|
✗ |
continue; |
144 |
|
|
|
145 |
|
✗ |
provider_code = AV_RB16(t35->payload); |
146 |
|
✗ |
provider_oriented_code = AV_RB32(t35->payload + 2); |
147 |
|
✗ |
if (provider_code != ITU_T_T35_PROVIDER_CODE_DOLBY || |
148 |
|
|
provider_oriented_code != 0x800) |
149 |
|
✗ |
continue; |
150 |
|
|
|
151 |
|
✗ |
if (s->strip) { |
152 |
|
✗ |
ff_cbs_delete_unit(frag, i); |
153 |
|
✗ |
return 0; |
154 |
|
|
} |
155 |
|
|
|
156 |
|
✗ |
ret = update_rpu(bsf, pkt, FF_DOVI_WRAP_T35, |
157 |
|
✗ |
t35->payload + 6, t35->payload_size - 6, |
158 |
|
|
&rpu, &rpu_size); |
159 |
|
✗ |
if (ret < 0) |
160 |
|
✗ |
return ret; |
161 |
|
|
|
162 |
|
✗ |
ref = av_buffer_create(rpu, rpu_size, av_buffer_default_free, NULL, 0); |
163 |
|
✗ |
if (!ref) { |
164 |
|
✗ |
av_free(rpu); |
165 |
|
✗ |
return AVERROR(ENOMEM); |
166 |
|
|
} |
167 |
|
|
|
168 |
|
✗ |
av_buffer_unref(&t35->payload_ref); |
169 |
|
✗ |
t35->payload_ref = ref; |
170 |
|
✗ |
t35->payload = rpu + 1; /* skip country code */ |
171 |
|
✗ |
t35->payload_size = rpu_size - 1; |
172 |
|
✗ |
break; /* should be only one RPU per packet */ |
173 |
|
|
} |
174 |
|
|
|
175 |
|
✗ |
return 0; |
176 |
|
|
} |
177 |
|
|
|
178 |
|
|
static const CBSBSFType dovi_rpu_hevc_type = { |
179 |
|
|
.codec_id = AV_CODEC_ID_HEVC, |
180 |
|
|
.fragment_name = "access unit", |
181 |
|
|
.unit_name = "NAL unit", |
182 |
|
|
.update_fragment = &dovi_rpu_update_fragment_hevc, |
183 |
|
|
}; |
184 |
|
|
|
185 |
|
|
static const CBSBSFType dovi_rpu_av1_type = { |
186 |
|
|
.codec_id = AV_CODEC_ID_AV1, |
187 |
|
|
.fragment_name = "temporal unit", |
188 |
|
|
.unit_name = "OBU", |
189 |
|
|
.update_fragment = &dovi_rpu_update_fragment_av1, |
190 |
|
|
}; |
191 |
|
|
|
192 |
|
✗ |
static int dovi_rpu_init(AVBSFContext *bsf) |
193 |
|
|
{ |
194 |
|
|
int ret; |
195 |
|
✗ |
DoviRpuContext *s = bsf->priv_data; |
196 |
|
✗ |
s->dec.logctx = s->enc.logctx = bsf; |
197 |
|
✗ |
s->enc.enable = 1; |
198 |
|
|
|
199 |
|
✗ |
if (s->compression == AV_DOVI_COMPRESSION_RESERVED) { |
200 |
|
✗ |
av_log(bsf, AV_LOG_ERROR, "Invalid compression level: %d\n", s->compression); |
201 |
|
✗ |
return AVERROR(EINVAL); |
202 |
|
|
} |
203 |
|
|
|
204 |
|
✗ |
if (s->strip) { |
205 |
|
✗ |
av_packet_side_data_remove(bsf->par_out->coded_side_data, |
206 |
|
✗ |
&bsf->par_out->nb_coded_side_data, |
207 |
|
|
AV_PKT_DATA_DOVI_CONF); |
208 |
|
|
} else { |
209 |
|
|
const AVPacketSideData *sd; |
210 |
|
✗ |
sd = av_packet_side_data_get(bsf->par_out->coded_side_data, |
211 |
|
✗ |
bsf->par_out->nb_coded_side_data, |
212 |
|
|
AV_PKT_DATA_DOVI_CONF); |
213 |
|
|
|
214 |
|
✗ |
if (sd) { |
215 |
|
|
AVDOVIDecoderConfigurationRecord *cfg; |
216 |
|
✗ |
cfg = (AVDOVIDecoderConfigurationRecord *) sd->data; |
217 |
|
✗ |
s->dec.cfg = *cfg; |
218 |
|
|
|
219 |
|
|
/* Update configuration record before setting to enc ctx */ |
220 |
|
✗ |
cfg->dv_md_compression = s->compression; |
221 |
|
✗ |
if (s->compression && s->dec.cfg.dv_profile < 8) { |
222 |
|
✗ |
av_log(bsf, AV_LOG_ERROR, "Invalid compression level %d for " |
223 |
|
✗ |
"Dolby Vision profile %d.\n", s->compression, s->dec.cfg.dv_profile); |
224 |
|
✗ |
return AVERROR(EINVAL); |
225 |
|
|
} |
226 |
|
|
|
227 |
|
✗ |
s->enc.cfg = *cfg; |
228 |
|
|
} else { |
229 |
|
✗ |
av_log(bsf, AV_LOG_WARNING, "No Dolby Vision configuration record " |
230 |
|
|
"found? Generating one, but results may be invalid.\n"); |
231 |
|
✗ |
ret = ff_dovi_configure_ext(&s->enc, bsf->par_out, NULL, s->compression, |
232 |
|
|
FF_COMPLIANCE_NORMAL); |
233 |
|
✗ |
if (ret < 0) |
234 |
|
✗ |
return ret; |
235 |
|
|
/* Be conservative in accepting all compressed RPUs */ |
236 |
|
✗ |
s->dec.cfg = s->enc.cfg; |
237 |
|
✗ |
s->dec.cfg.dv_md_compression = AV_DOVI_COMPRESSION_EXTENDED; |
238 |
|
|
} |
239 |
|
|
} |
240 |
|
|
|
241 |
|
✗ |
switch (bsf->par_in->codec_id) { |
242 |
|
✗ |
case AV_CODEC_ID_HEVC: |
243 |
|
✗ |
return ff_cbs_bsf_generic_init(bsf, &dovi_rpu_hevc_type); |
244 |
|
✗ |
case AV_CODEC_ID_AV1: |
245 |
|
✗ |
return ff_cbs_bsf_generic_init(bsf, &dovi_rpu_av1_type); |
246 |
|
✗ |
default: |
247 |
|
✗ |
return AVERROR_BUG; |
248 |
|
|
} |
249 |
|
|
} |
250 |
|
|
|
251 |
|
✗ |
static void dovi_rpu_close(AVBSFContext *bsf) |
252 |
|
|
{ |
253 |
|
✗ |
DoviRpuContext *s = bsf->priv_data; |
254 |
|
✗ |
ff_dovi_ctx_unref(&s->dec); |
255 |
|
✗ |
ff_dovi_ctx_unref(&s->enc); |
256 |
|
✗ |
ff_cbs_bsf_generic_close(bsf); |
257 |
|
✗ |
} |
258 |
|
|
|
259 |
|
|
#define OFFSET(x) offsetof(DoviRpuContext, x) |
260 |
|
|
#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM) |
261 |
|
|
static const AVOption dovi_rpu_options[] = { |
262 |
|
|
{ "strip", "Strip Dolby Vision metadata", OFFSET(strip), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS }, |
263 |
|
|
{ "compression", "DV metadata compression mode", OFFSET(compression), AV_OPT_TYPE_INT, { .i64 = AV_DOVI_COMPRESSION_LIMITED }, 0, AV_DOVI_COMPRESSION_EXTENDED, FLAGS, .unit = "compression" }, |
264 |
|
|
{ "none", "Don't compress metadata", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, .flags = FLAGS, .unit = "compression" }, |
265 |
|
|
{ "limited", "Limited metadata compression", 0, AV_OPT_TYPE_CONST, {.i64 = AV_DOVI_COMPRESSION_LIMITED}, .flags = FLAGS, .unit = "compression" }, |
266 |
|
|
{ "extended", "Extended metadata compression",0, AV_OPT_TYPE_CONST, {.i64 = AV_DOVI_COMPRESSION_EXTENDED}, .flags = FLAGS, .unit = "compression" }, |
267 |
|
|
{ NULL } |
268 |
|
|
}; |
269 |
|
|
|
270 |
|
|
static const AVClass dovi_rpu_class = { |
271 |
|
|
.class_name = "dovi_rpu_bsf", |
272 |
|
|
.item_name = av_default_item_name, |
273 |
|
|
.option = dovi_rpu_options, |
274 |
|
|
.version = LIBAVUTIL_VERSION_INT, |
275 |
|
|
}; |
276 |
|
|
|
277 |
|
|
static const enum AVCodecID dovi_rpu_codec_ids[] = { |
278 |
|
|
AV_CODEC_ID_HEVC, AV_CODEC_ID_AV1, AV_CODEC_ID_NONE, |
279 |
|
|
}; |
280 |
|
|
|
281 |
|
|
const FFBitStreamFilter ff_dovi_rpu_bsf = { |
282 |
|
|
.p.name = "dovi_rpu", |
283 |
|
|
.p.codec_ids = dovi_rpu_codec_ids, |
284 |
|
|
.p.priv_class = &dovi_rpu_class, |
285 |
|
|
.priv_data_size = sizeof(DoviRpuContext), |
286 |
|
|
.init = &dovi_rpu_init, |
287 |
|
|
.close = &dovi_rpu_close, |
288 |
|
|
.filter = &ff_cbs_bsf_generic_filter, |
289 |
|
|
}; |
290 |
|
|
|