FFmpeg: libavcodec/libx265.c Source File

FFmpeg

[フレーム]

libavcodec

libx265.c

Go to the documentation of this file.

1 /*

2 * libx265 encoder

3 *

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #if defined(_MSC_VER)

24 #define X265_API_IMPORTS 1

25 #endif

27 #include <x265.h>

28 #include <float.h>

30 #include "libavutil/internal.h"

31 #include "libavutil/common.h"

32 #include "libavutil/opt.h"

33 #include "libavutil/pixdesc.h"

34 #include "avcodec.h"

35 #include "internal.h"

37 typedef struct libx265Context {

38 const AVClass *class;

40 x265_encoder *encoder;

41 x265_param *params;

43 float crf;

44 char *preset;

45 char *tune;

46 char *x265_opts;

47 } libx265Context;

49 static int is_keyframe(NalUnitType naltype)

50 {

51 switch (naltype) {

52 case NAL_UNIT_CODED_SLICE_BLA_W_LP:

53 case NAL_UNIT_CODED_SLICE_BLA_W_RADL:

54 case NAL_UNIT_CODED_SLICE_BLA_N_LP:

55 case NAL_UNIT_CODED_SLICE_IDR_W_RADL:

56 case NAL_UNIT_CODED_SLICE_IDR_N_LP:

57 case NAL_UNIT_CODED_SLICE_CRA:

58 return 1;

59 default:

60 return 0;

61 }

62 }

64 static av_cold int libx265_encode_close(AVCodecContext *avctx)

65 {

66 libx265Context *ctx = avctx->priv_data;

68 av_frame_free(&avctx->coded_frame);

70 x265_param_free(ctx->params);

72 if (ctx->encoder)

73 x265_encoder_close(ctx->encoder);

75 return 0;

76 }

78 static av_cold int libx265_encode_init(AVCodecContext *avctx)

79 {

80 libx265Context *ctx = avctx->priv_data;

82 if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL &&

83 !av_pix_fmt_desc_get(avctx->pix_fmt)->log2_chroma_w) {

84 av_log(avctx, AV_LOG_ERROR,

85 "4:2:2 and 4:4:4 support is not fully defined for HEVC yet. "

86 "Set -strict experimental to encode anyway.\n");

87 return AVERROR(ENOSYS);

88 }

90 avctx->coded_frame = av_frame_alloc();

91 if (!avctx->coded_frame) {

92 av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n");

93 return AVERROR(ENOMEM);

94 }

96 ctx->params = x265_param_alloc();

97 if (!ctx->params) {

98 av_log(avctx, AV_LOG_ERROR, "Could not allocate x265 param structure.\n");

99 return AVERROR(ENOMEM);

100 }

101

102 if (x265_param_default_preset(ctx->params, ctx->preset, ctx->tune) < 0) {

103 av_log(avctx, AV_LOG_ERROR, "Invalid preset or tune.\n");

104 return AVERROR(EINVAL);

105 }

106

107 ctx->params->frameNumThreads = avctx->thread_count;

108 ctx->params->fpsNum = avctx->time_base.den;

109 ctx->params->fpsDenom = avctx->time_base.num * avctx->ticks_per_frame;

110 ctx->params->sourceWidth = avctx->width;

111 ctx->params->sourceHeight = avctx->height;

112 ctx->params->bEnablePsnr = !!(avctx->flags & CODEC_FLAG_PSNR);

113

114 if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {

115 char sar[12];

116 int sar_num, sar_den;

117

118 av_reduce(&sar_num, &sar_den,

119 avctx->sample_aspect_ratio.num,

120 avctx->sample_aspect_ratio.den, 65535);

121 snprintf(sar, sizeof(sar), "%d:%d", sar_num, sar_den);

122 if (x265_param_parse(ctx->params, "sar", sar) == X265_PARAM_BAD_VALUE) {

123 av_log(avctx, AV_LOG_ERROR, "Invalid SAR: %d:%d.\n", sar_num, sar_den);

124 return AVERROR_INVALIDDATA;

125 }

126 }

127

128 switch (avctx->pix_fmt) {

129 case AV_PIX_FMT_YUV420P:

130 case AV_PIX_FMT_YUV420P10:

131 ctx->params->internalCsp = X265_CSP_I420;

132 break;

133 case AV_PIX_FMT_YUV422P:

134 case AV_PIX_FMT_YUV422P10:

135 ctx->params->internalCsp = X265_CSP_I422;

136 break;

137 case AV_PIX_FMT_YUV444P:

138 case AV_PIX_FMT_YUV444P10:

139 ctx->params->internalCsp = X265_CSP_I444;

140 break;

141 }

142

143 if (ctx->crf >= 0) {

144 char crf[6];

145

146 snprintf(crf, sizeof(crf), "%2.2f", ctx->crf);

147 if (x265_param_parse(ctx->params, "crf", crf) == X265_PARAM_BAD_VALUE) {

148 av_log(avctx, AV_LOG_ERROR, "Invalid crf: %2.2f.\n", ctx->crf);

149 return AVERROR(EINVAL);

150 }

151 } else if (avctx->bit_rate > 0) {

152 ctx->params->rc.bitrate = avctx->bit_rate / 1000;

153 ctx->params->rc.rateControlMode = X265_RC_ABR;

154 }

155

156 if (!(avctx->flags & CODEC_FLAG_GLOBAL_HEADER))

157 ctx->params->bRepeatHeaders = 1;

158

159 if (ctx->x265_opts) {

160 AVDictionary *dict = NULL;

161 AVDictionaryEntry *en = NULL;

162

163 if (!av_dict_parse_string(&dict, ctx->x265_opts, "=", ":", 0)) {

164 while ((en = av_dict_get(dict, "", en, AV_DICT_IGNORE_SUFFIX))) {

165 int parse_ret = x265_param_parse(ctx->params, en->key, en->value);

166

167 switch (parse_ret) {

168 case X265_PARAM_BAD_NAME:

169 av_log(avctx, AV_LOG_WARNING,

170 "Unknown option: %s.\n", en->key);

171 break;

172 case X265_PARAM_BAD_VALUE:

173 av_log(avctx, AV_LOG_WARNING,

174 "Invalid value for %s: %s.\n", en->key, en->value);

175 break;

176 default:

177 break;

178 }

179 }

180 av_dict_free(&dict);

181 }

182 }

183

184 ctx->encoder = x265_encoder_open(ctx->params);

185 if (!ctx->encoder) {

186 av_log(avctx, AV_LOG_ERROR, "Cannot open libx265 encoder.\n");

187 libx265_encode_close(avctx);

188 return AVERROR_INVALIDDATA;

189 }

190

191 if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {

192 x265_nal *nal;

193 int nnal;

194

195 avctx->extradata_size = x265_encoder_headers(ctx->encoder, &nal, &nnal);

196 if (avctx->extradata_size <= 0) {

197 av_log(avctx, AV_LOG_ERROR, "Cannot encode headers.\n");

198 libx265_encode_close(avctx);

199 return AVERROR_INVALIDDATA;

200 }

201

202 avctx->extradata = av_malloc(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

203 if (!avctx->extradata) {

204 av_log(avctx, AV_LOG_ERROR,

205 "Cannot allocate HEVC header of size %d.\n", avctx->extradata_size);

206 libx265_encode_close(avctx);

207 return AVERROR(ENOMEM);

208 }

209

210 memcpy(avctx->extradata, nal[0].payload, avctx->extradata_size);

211 }

212

213 return 0;

214 }

215

216 static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

217 const AVFrame *pic, int *got_packet)

218 {

219 libx265Context *ctx = avctx->priv_data;

220 x265_picture x265pic;

221 x265_picture x265pic_out = { { 0 } };

222 x265_nal *nal;

223 uint8_t *dst;

224 int payload = 0;

225 int nnal;

226 int ret;

227 int i;

228

229 x265_picture_init(ctx->params, &x265pic);

230

231 if (pic) {

232 for (i = 0; i < 3; i++) {

233 x265pic.planes[i] = pic->data[i];

234 x265pic.stride[i] = pic->linesize[i];

235 }

236

237 x265pic.pts = pic->pts;

238 x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth_minus1 + 1;

239

240 x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ? X265_TYPE_I :

241 pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :

242 pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :

243 X265_TYPE_AUTO;

244 }

245

246 ret = x265_encoder_encode(ctx->encoder, &nal, &nnal,

247 pic ? &x265pic : NULL, &x265pic_out);

248 if (ret < 0)

249 return AVERROR_EXTERNAL;

250

251 if (!nnal)

252 return 0;

253

254 for (i = 0; i < nnal; i++)

255 payload += nal[i].sizeBytes;

256

257 ret = ff_alloc_packet(pkt, payload);

258 if (ret < 0) {

259 av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

260 return ret;

261 }

262 dst = pkt->data;

263

264 for (i = 0; i < nnal; i++) {

265 memcpy(dst, nal[i].payload, nal[i].sizeBytes);

266 dst += nal[i].sizeBytes;

267

268 if (is_keyframe(nal[i].type))

269 pkt->flags |= AV_PKT_FLAG_KEY;

270 }

271

272 pkt->pts = x265pic_out.pts;

273 pkt->dts = x265pic_out.dts;

274

275 *got_packet = 1;

276 return 0;

277 }

278

279 static const enum AVPixelFormat x265_csp_eight[] = {

280 AV_PIX_FMT_YUV420P,

281 AV_PIX_FMT_YUV422P,

282 AV_PIX_FMT_YUV444P,

283 AV_PIX_FMT_NONE

284 };

285

286 static const enum AVPixelFormat x265_csp_twelve[] = {

287 AV_PIX_FMT_YUV420P,

288 AV_PIX_FMT_YUV422P,

289 AV_PIX_FMT_YUV444P,

290 AV_PIX_FMT_YUV420P10,

291 AV_PIX_FMT_YUV422P10,

292 AV_PIX_FMT_YUV444P10,

293 AV_PIX_FMT_NONE

294 };

295

296 static av_cold void libx265_encode_init_csp(AVCodec *codec)

297 {

298 if (x265_max_bit_depth == 8)

299 codec->pix_fmts = x265_csp_eight;

300 else if (x265_max_bit_depth == 12)

301 codec->pix_fmts = x265_csp_twelve;

302 }

303

304 #define OFFSET(x) offsetof(libx265Context, x)

305 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

306 static const AVOption options[] = {

307 { "crf", "set the x265 crf", OFFSET(crf), AV_OPT_TYPE_FLOAT, { .dbl = -1 }, -1, FLT_MAX, VE },

308 { "preset", "set the x265 preset", OFFSET(preset), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },

309 { "tune", "set the x265 tune parameter", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },

310 { "x265-params", "set the x265 configuration using a :-separated list of key=value parameters", OFFSET(x265_opts), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },

311 { NULL }

312 };

313

314 static const AVClass class = {

315 .class_name = "libx265",

316 .item_name = av_default_item_name,

317 .option = options,

318 .version = LIBAVUTIL_VERSION_INT,

319 };

320

321 static const AVCodecDefault x265_defaults[] = {

322 { "b", "0" },

323 { NULL },

324 };

325

326 AVCodec ff_libx265_encoder = {

327 .name = "libx265",

328 .long_name = NULL_IF_CONFIG_SMALL("libx265 H.265 / HEVC"),

329 .type = AVMEDIA_TYPE_VIDEO,

330 .id = AV_CODEC_ID_HEVC,

331 .init = libx265_encode_init,

332 .init_static_data = libx265_encode_init_csp,

333 .encode2 = libx265_encode_frame,

334 .close = libx265_encode_close,

335 .priv_data_size = sizeof(libx265Context),

336 .priv_class = &class,

337 .defaults = x265_defaults,

338 .capabilities = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,

339 };

Generated on Sun Mar 8 2015 02:34:55 for FFmpeg by doxygen 1.8.2