~diresu/blender/blender-command-port

static const char * const x264_transfer_names[] = { "", "bt709", "undef", "", "bt470m", "bt470bg", "smpte170m", "smpte240m", "linear", "log100", "log316", 0 };

static const char * const x264_colmatrix_names[] = { "GBR", "bt709", "undef", "", "fcc", "bt470bg", "smpte170m", "smpte240m", "YCgCo", 0 };

/* Colorspace type

* legacy only; nothing other than I420 is really supported.

#define X264_CSP_MASK 0x00ff /* */

#define X264_CSP_NONE 0x0000 /* Invalid mode */

100

#define X264_CSP_I420 0x0001 /* yuv 4:2:0 planar */

101

#define X264_CSP_I422 0x0002 /* yuv 4:2:2 planar */

102

#define X264_CSP_I444 0x0003 /* yuv 4:4:4 planar */

103

#define X264_CSP_YV12 0x0004 /* yuv 4:2:0 planar */

104

#define X264_CSP_YUYV 0x0005 /* yuv 4:2:2 packed */

105

#define X264_CSP_RGB 0x0006 /* rgb 24bits */

106

#define X264_CSP_BGR 0x0007 /* bgr 24bits */

107

#define X264_CSP_BGRA 0x0008 /* bgr 32bits */

108

#define X264_CSP_MAX 0x0009 /* end of list */

109

#define X264_CSP_VFLIP 0x1000 /* */

110

111

/* Slice type

112

113

#define X264_TYPE_AUTO 0x0000 /* Let x264 choose the right type */

114

#define X264_TYPE_IDR 0x0001

115

#define X264_TYPE_I 0x0002

116

#define X264_TYPE_P 0x0003

117

#define X264_TYPE_BREF 0x0004 /* Non-disposable B-frame */

118

#define X264_TYPE_B 0x0005

119

#define IS_X264_TYPE_I(x) ((x)==X264_TYPE_I || (x)==X264_TYPE_IDR)

120

#define IS_X264_TYPE_B(x) ((x)==X264_TYPE_B || (x)==X264_TYPE_BREF)

121

122

/* Log level

123

124

#define X264_LOG_NONE (-1)

125

#define X264_LOG_ERROR 0

126

#define X264_LOG_WARNING 1

127

#define X264_LOG_INFO 2

128

#define X264_LOG_DEBUG 3

129

130

/* Zones: override ratecontrol or other options for specific sections of the video.

131

* See x264_encoder_reconfig() for which options can be changed.

132

* If zones overlap, whichever comes later in the list takes precedence. */

133

typedef struct

134

{

135

int i_start, i_end; /* range of frame numbers */

136

int b_force_qp; /* whether to use qp vs bitrate factor */

137

int i_qp;

138

float f_bitrate_factor;

139

struct x264_param_t *param;

140

} x264_zone_t;

141

142

typedef struct x264_param_t

143

{

144

/* CPU flags */

145

unsigned int cpu;

146

int i_threads; /* encode multiple frames in parallel */

147

int b_deterministic; /* whether to allow non-deterministic optimizations when threaded */

148

149

/* Video Properties */

150

int i_width;

151

int i_height;

152

int i_csp; /* CSP of encoded bitstream, only i420 supported */

153

int i_level_idc;

154

int i_frame_total; /* number of frames to encode if known, else 0 */

155

156

struct

157

{

158

/* they will be reduced to be 0 < x <= 65535 and prime */

159

int i_sar_height;

160

int i_sar_width;

161

162

int i_overscan; /* 0=undef, 1=no overscan, 2=overscan */

163

164

/* see h264 annex E for the values of the following */

165

int i_vidformat;

166

int b_fullrange;

167

int i_colorprim;

168

int i_transfer;

169

int i_colmatrix;

170

int i_chroma_loc; /* both top & bottom */

171

} vui;

172

173

int i_fps_num;

174

int i_fps_den;

175

176

/* Bitstream parameters */

177

int i_frame_reference; /* Maximum number of reference frames */

178

int i_keyint_max; /* Force an IDR keyframe at this interval */

179

int i_keyint_min; /* Scenecuts closer together than this are coded as I, not IDR. */

180

int i_scenecut_threshold; /* how aggressively to insert extra I frames */

181

int b_pre_scenecut; /* compute scenecut on lowres frames */

182

int i_bframe; /* how many b-frame between 2 references pictures */

183

int b_bframe_adaptive;

184

int i_bframe_bias;

185

int b_bframe_pyramid; /* Keep some B-frames as references */

186

187

int b_deblocking_filter;

188

int i_deblocking_filter_alphac0; /* [-6, 6] -6 light filter, 6 strong */

189

int i_deblocking_filter_beta; /* [-6, 6] idem */

190

191

int b_cabac;

192

int i_cabac_init_idc;

193

194

int b_interlaced;

195

196

int i_cqm_preset;

197

char *psz_cqm_file; /* JM format */

198

uint8_t cqm_4iy[16]; /* used only if i_cqm_preset == X264_CQM_CUSTOM */

199

uint8_t cqm_4ic[16];

200

uint8_t cqm_4py[16];

201

uint8_t cqm_4pc[16];

202

uint8_t cqm_8iy[64];

203

uint8_t cqm_8py[64];

204

205

/* Log */

206

void (*pf_log)( void *, int i_level, const char *psz, va_list );

207

void *p_log_private;

208

int i_log_level;

209

int b_visualize;

210

211

/* Encoder analyser parameters */

212

struct

213

{

214

unsigned int intra; /* intra partitions */

215

unsigned int inter; /* inter partitions */

216

217

int b_transform_8x8;

218

int b_weighted_bipred; /* implicit weighting for B-frames */

219

int i_direct_mv_pred; /* spatial vs temporal mv prediction */

220

int i_direct_8x8_inference; /* forbid 4x4 direct partitions. -1 = auto, based on level */

221

int i_chroma_qp_offset;

222

223

int i_me_method; /* motion estimation algorithm to use (X264_ME_*) */

224

int i_me_range; /* integer pixel motion estimation search range (from predicted mv) */

225

int i_mv_range; /* maximum length of a mv (in pixels). -1 = auto, based on level */

226

int i_mv_range_thread; /* minimum space between threads. -1 = auto, based on number of threads. */

227

int i_subpel_refine; /* subpixel motion estimation quality */

228

int b_bidir_me; /* jointly optimize both MVs in B-frames */

229

int b_chroma_me; /* chroma ME for subpel and mode decision in P-frames */

230

int b_bframe_rdo; /* RD based mode decision for B-frames */

231

int b_mixed_references; /* allow each mb partition in P-frames to have it's own reference number */

232

int i_trellis; /* trellis RD quantization */

233

int b_fast_pskip; /* early SKIP detection on P-frames */

234

int b_dct_decimate; /* transform coefficient thresholding on P-frames */

235

int i_noise_reduction; /* adaptive pseudo-deadzone */

236

237

/* the deadzone size that will be used in luma quantization */

238

int i_luma_deadzone[2]; /* {inter, intra} */

239

240

int b_psnr; /* compute and print PSNR stats */

241

int b_ssim; /* compute and print SSIM stats */

242

} analyse;

243

244

/* Rate control parameters */

245

struct

246

{

247

int i_rc_method; /* X264_RC_* */

248

249

int i_qp_constant; /* 0-51 */

250

int i_qp_min; /* min allowed QP value */

251

int i_qp_max; /* max allowed QP value */

252

int i_qp_step; /* max QP step between frames */

253

254

int i_bitrate;

255

float f_rf_constant; /* 1pass VBR, nominal QP */

256

float f_rate_tolerance;

257

int i_vbv_max_bitrate;

258

int i_vbv_buffer_size;

259

float f_vbv_buffer_init; /* <=1: fraction of buffer_size. >1: kbit */

260

float f_ip_factor;

261

float f_pb_factor;

262

263

/* 2pass */

264

int b_stat_write; /* Enable stat writing in psz_stat_out */

265

char *psz_stat_out;

266

int b_stat_read; /* Read stat from psz_stat_in and use it */

267

char *psz_stat_in;

268

269

/* 2pass params (same as ffmpeg ones) */

270

char *psz_rc_eq; /* 2 pass rate control equation */

271

float f_qcompress; /* 0.0 => cbr, 1.0 => constant qp */

272

float f_qblur; /* temporally blur quants */

273

float f_complexity_blur; /* temporally blur complexity */

274

x264_zone_t *zones; /* ratecontrol overrides */

275

int i_zones; /* number of zone_t's */

276

char *psz_zones; /* alternate method of specifying zones */

277

} rc;

278

279

/* Muxing parameters */

280

int b_aud; /* generate access unit delimiters */

281

int b_repeat_headers; /* put SPS/PPS before each keyframe */

282

int i_sps_id; /* SPS and PPS id number */

283

} x264_param_t;

284

285

typedef struct {

286

int level_idc;

287

int mbps; /* max macroblock processing rate (macroblocks/sec) */

288

int frame_size; /* max frame size (macroblocks) */

289

int dpb; /* max decoded picture buffer (bytes) */

290

int bitrate; /* max bitrate (kbit/sec) */

291

int cpb; /* max vbv buffer (kbit) */

292

int mv_range; /* max vertical mv component range (pixels) */

293

int mvs_per_2mb; /* max mvs per 2 consecutive mbs. */

294

int slice_rate; /* ?? */

295

int bipred8x8; /* limit bipred to >=8x8 */

296

int direct8x8; /* limit b_direct to >=8x8 */

297

int frame_only; /* forbid interlacing */

298

} x264_level_t;

299

300

/* all of the levels defined in the standard, terminated by .level_idc=0 */

301

extern const x264_level_t x264_levels[];

302

303

/* x264_param_default:

304

* fill x264_param_t with default values and do CPU detection */

305

void x264_param_default( x264_param_t * );

306

307

/* x264_param_parse:

308

* set one parameter by name.

309

* returns 0 on success, or returns one of the following errors.

310

* note: BAD_VALUE occurs only if it can't even parse the value,

311

* numerical range is not checked until x264_encoder_open() or

312

* x264_encoder_reconfig().

313

* value=NULL means "true" for boolean options, but is a BAD_VALUE for non-booleans. */

314

#define X264_PARAM_BAD_NAME (-1)

315

#define X264_PARAM_BAD_VALUE (-2)

316

int x264_param_parse( x264_param_t *, const char *name, const char *value );

317

318

/****************************************************************************

319

* Picture structures and functions.

320

****************************************************************************/

321

typedef struct

322

{

323

int i_csp;

324

325

int i_plane;

326

int i_stride[4];

327

uint8_t *plane[4];

328

} x264_image_t;

329

330

typedef struct

331

{

332

/* In: force picture type (if not auto) XXX: ignored for now

333

* Out: type of the picture encoded */

334

int i_type;

335

/* In: force quantizer for > 0 */

336

int i_qpplus1;

337

/* In: user pts, Out: pts of encoded picture (user)*/

338

int64_t i_pts;

339

340

/* In: raw data */

341

x264_image_t img;

342

} x264_picture_t;

343

344

/* x264_picture_alloc:

345

* alloc data for a picture. You must call x264_picture_clean on it. */

346

void x264_picture_alloc( x264_picture_t *pic, int i_csp, int i_width, int i_height );

347

348

/* x264_picture_clean:

349

* free associated resource for a x264_picture_t allocated with

350

* x264_picture_alloc ONLY */

351

void x264_picture_clean( x264_picture_t *pic );

352

353

/****************************************************************************

354

* NAL structure and functions:

355

****************************************************************************/

356

/* nal */

357

enum nal_unit_type_e

358

{

359

NAL_UNKNOWN = 0,

360

NAL_SLICE = 1,

361

NAL_SLICE_DPA = 2,

362

NAL_SLICE_DPB = 3,

363

NAL_SLICE_DPC = 4,

364

NAL_SLICE_IDR = 5, /* ref_idc != 0 */

365

NAL_SEI = 6, /* ref_idc == 0 */

366

NAL_SPS = 7,

367

NAL_PPS = 8,

368

NAL_AUD = 9,

369

/* ref_idc == 0 for 6,9,10,11,12 */

370

};

371

enum nal_priority_e

372

{

373

NAL_PRIORITY_DISPOSABLE = 0,

374

NAL_PRIORITY_LOW = 1,

375

NAL_PRIORITY_HIGH = 2,

376

NAL_PRIORITY_HIGHEST = 3,

377

};

378

379

typedef struct

380

{

381

int i_ref_idc; /* nal_priority_e */

382

int i_type; /* nal_unit_type_e */

383

384

/* This data are raw payload */

385

int i_payload;

386

uint8_t *p_payload;

387

} x264_nal_t;

388

389

/* x264_nal_encode:

390

* encode a nal into a buffer, setting the size.

391

* if b_annexeb then a long synch work is added

392

* XXX: it currently doesn't check for overflow */

393

int x264_nal_encode( void *, int *, int b_annexeb, x264_nal_t *nal );

394

395

/* x264_nal_decode:

396

* decode a buffer nal into a x264_nal_t */

397

int x264_nal_decode( x264_nal_t *nal, void *, int );

398

399

/****************************************************************************

400

* Encoder functions:

401

****************************************************************************/

402

403

/* x264_encoder_open:

404

* create a new encoder handler, all parameters from x264_param_t are copied */

405

x264_t *x264_encoder_open ( x264_param_t * );

406

/* x264_encoder_reconfig:

407

* change encoder options while encoding,

408

* analysis-related parameters from x264_param_t are copied */

409

int x264_encoder_reconfig( x264_t *, x264_param_t * );

410

/* x264_encoder_headers:

411

* return the SPS and PPS that will be used for the whole stream */

412

int x264_encoder_headers( x264_t *, x264_nal_t **, int * );

413

/* x264_encoder_encode:

414

* encode one picture */

415

int x264_encoder_encode ( x264_t *, x264_nal_t **, int *, x264_picture_t *, x264_picture_t * );

416

/* x264_encoder_close:

417

* close an encoder handler */

418

void x264_encoder_close ( x264_t * );

419

420

#endif

Older »