source/x265.cpp

   1 /*****************************************************************************
   2  * Copyright (C) 2013 x265 project
   3  *
   4  * Authors: Steve Borho <steve@borho.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  19  *
  20  * This program is also available under a commercial proprietary license.
  21  * For more information, contact us at license @ x265.com.
  22  *****************************************************************************/
  23
  24 #if _MSC_VER
  25 #pragma warning(disable: 4127) // conditional expression is constant, yes I know
  26 #endif
  27
  28 #include "input/input.h"
  29 #include "output/output.h"
  30 #include "filters/filters.h"
  31 #include "common.h"
  32 #include "param.h"
  33 #include "cpu.h"
  34 #include "x265.h"
  35
  36 #if HAVE_VLD
  37 /* Visual Leak Detector */
  38 #include <vld.h>
  39 #endif
  40
  41 #include <signal.h>
  42 #include <errno.h>
  43 #include <fcntl.h>
  44 #include <getopt.h>
  45
  46 #include <string>
  47 #include <ostream>
  48 #include <fstream>
  49
  50 #ifdef _WIN32
  51 #include <windows.h>
  52 #else
  53 #define GetConsoleTitle(t, n)
  54 #define SetConsoleTitle(t)
  55 #endif
  56
  57 using namespace x265;
  58
  59 static const char short_options[] = "o:p:f:F:r:I:i:b:s:t:q:m:hwV?";
  60 static const struct option long_options[] =
  61 {
  62     { "help",                 no_argument, NULL, 'h' },
  63     { "version",              no_argument, NULL, 'V' },
  64     { "asm",            required_argument, NULL, 0 },
  65     { "no-asm",               no_argument, NULL, 0 },
  66     { "threads",        required_argument, NULL, 0 },
  67     { "preset",         required_argument, NULL, 'p' },
  68     { "tune",           required_argument, NULL, 't' },
  69     { "frame-threads",  required_argument, NULL, 'F' },
  70     { "no-pmode",             no_argument, NULL, 0 },
  71     { "pmode",                no_argument, NULL, 0 },
  72     { "no-pme",               no_argument, NULL, 0 },
  73     { "pme",                  no_argument, NULL, 0 },
  74     { "log-level",      required_argument, NULL, 0 },
  75     { "profile",        required_argument, NULL, 0 },
  76     { "level-idc",      required_argument, NULL, 0 },
  77     { "high-tier",            no_argument, NULL, 0 },
  78     { "no-high-tier",         no_argument, NULL, 0 },
  79     { "csv",            required_argument, NULL, 0 },
  80     { "no-cu-stats",          no_argument, NULL, 0 },
  81     { "cu-stats",             no_argument, NULL, 0 },
  82     { "y4m",                  no_argument, NULL, 0 },
  83     { "no-progress",          no_argument, NULL, 0 },
  84     { "output",         required_argument, NULL, 'o' },
  85     { "input",          required_argument, NULL, 0 },
  86     { "input-depth",    required_argument, NULL, 0 },
  87     { "input-res",      required_argument, NULL, 0 },
  88     { "input-csp",      required_argument, NULL, 0 },
  89     { "interlace",      required_argument, NULL, 0 },
  90     { "no-interlace",         no_argument, NULL, 0 },
  91     { "fps",            required_argument, NULL, 0 },
  92     { "seek",           required_argument, NULL, 0 },
  93     { "frame-skip",     required_argument, NULL, 0 },
  94     { "frames",         required_argument, NULL, 'f' },
  95     { "recon",          required_argument, NULL, 'r' },
  96     { "recon-depth",    required_argument, NULL, 0 },
  97     { "no-wpp",               no_argument, NULL, 0 },
  98     { "wpp",                  no_argument, NULL, 0 },
  99     { "ctu",            required_argument, NULL, 's' },
 100     { "tu-intra-depth", required_argument, NULL, 0 },
 101     { "tu-inter-depth", required_argument, NULL, 0 },
 102     { "me",             required_argument, NULL, 0 },
 103     { "subme",          required_argument, NULL, 'm' },
 104     { "merange",        required_argument, NULL, 0 },
 105     { "max-merge",      required_argument, NULL, 0 },
 106     { "no-temporal-mvp",      no_argument, NULL, 0 },
 107     { "temporal-mvp",         no_argument, NULL, 0 },
 108     { "rdpenalty",      required_argument, NULL, 0 },
 109     { "no-rect",              no_argument, NULL, 0 },
 110     { "rect",                 no_argument, NULL, 0 },
 111     { "no-amp",               no_argument, NULL, 0 },
 112     { "amp",                  no_argument, NULL, 0 },
 113     { "no-early-skip",        no_argument, NULL, 0 },
 114     { "early-skip",           no_argument, NULL, 0 },
 115     { "no-fast-cbf",          no_argument, NULL, 0 },
 116     { "fast-cbf",             no_argument, NULL, 0 },
 117     { "no-tskip",             no_argument, NULL, 0 },
 118     { "tskip",                no_argument, NULL, 0 },
 119     { "no-tskip-fast",        no_argument, NULL, 0 },
 120     { "tskip-fast",           no_argument, NULL, 0 },
 121     { "cu-lossless",          no_argument, NULL, 0 },
 122     { "no-cu-lossless",       no_argument, NULL, 0 },
 123     { "no-constrained-intra", no_argument, NULL, 0 },
 124     { "constrained-intra",    no_argument, NULL, 0 },
 125     { "fast-intra",           no_argument, NULL, 0 },
 126     { "no-fast-intra",        no_argument, NULL, 0 },
 127     { "no-open-gop",          no_argument, NULL, 0 },
 128     { "open-gop",             no_argument, NULL, 0 },
 129     { "keyint",         required_argument, NULL, 'I' },
 130     { "min-keyint",     required_argument, NULL, 'i' },
 131     { "scenecut",       required_argument, NULL, 0 },
 132     { "no-scenecut",          no_argument, NULL, 0 },
 133     { "rc-lookahead",   required_argument, NULL, 0 },
 134     { "bframes",        required_argument, NULL, 'b' },
 135     { "bframe-bias",    required_argument, NULL, 0 },
 136     { "b-adapt",        required_argument, NULL, 0 },
 137     { "no-b-adapt",           no_argument, NULL, 0 },
 138     { "no-b-pyramid",         no_argument, NULL, 0 },
 139     { "b-pyramid",            no_argument, NULL, 0 },
 140     { "ref",            required_argument, NULL, 0 },
 141     { "no-weightp",           no_argument, NULL, 0 },
 142     { "weightp",              no_argument, NULL, 'w' },
 143     { "no-weightb",           no_argument, NULL, 0 },
 144     { "weightb",              no_argument, NULL, 0 },
 145     { "crf",            required_argument, NULL, 0 },
 146     { "crf-max",        required_argument, NULL, 0 },
 147     { "crf-min",        required_argument, NULL, 0 },
 148     { "vbv-maxrate",    required_argument, NULL, 0 },
 149     { "vbv-bufsize",    required_argument, NULL, 0 },
 150     { "vbv-init",       required_argument, NULL, 0 },
 151     { "bitrate",        required_argument, NULL, 0 },
 152     { "qp",             required_argument, NULL, 'q' },
 153     { "aq-mode",        required_argument, NULL, 0 },
 154     { "aq-strength",    required_argument, NULL, 0 },
 155     { "ipratio",        required_argument, NULL, 0 },
 156     { "pbratio",        required_argument, NULL, 0 },
 157     { "qcomp",          required_argument, NULL, 0 },
 158     { "qpstep",         required_argument, NULL, 0 },
 159     { "ratetol",        required_argument, NULL, 0 },
 160     { "cplxblur",       required_argument, NULL, 0 },
 161     { "qblur",          required_argument, NULL, 0 },
 162     { "cbqpoffs",       required_argument, NULL, 0 },
 163     { "crqpoffs",       required_argument, NULL, 0 },
 164     { "rd",             required_argument, NULL, 0 },
 165     { "psy-rd",         required_argument, NULL, 0 },
 166     { "psy-rdoq",       required_argument, NULL, 0 },
 167     { "scaling-list",   required_argument, NULL, 0 },
 168     { "lossless",             no_argument, NULL, 0 },
 169     { "no-lossless",          no_argument, NULL, 0 },
 170     { "no-signhide",          no_argument, NULL, 0 },
 171     { "signhide",             no_argument, NULL, 0 },
 172     { "no-lft",               no_argument, NULL, 0 }, /* DEPRECATED */
 173     { "lft",                  no_argument, NULL, 0 }, /* DEPRECATED */
 174     { "no-deblock",           no_argument, NULL, 0 },
 175     { "deblock",        required_argument, NULL, 0 },
 176     { "no-sao",               no_argument, NULL, 0 },
 177     { "sao",                  no_argument, NULL, 0 },
 178     { "no-sao-non-deblock",   no_argument, NULL, 0 },
 179     { "sao-non-deblock",      no_argument, NULL, 0 },
 180     { "no-ssim",              no_argument, NULL, 0 },
 181     { "ssim",                 no_argument, NULL, 0 },
 182     { "no-psnr",              no_argument, NULL, 0 },
 183     { "psnr",                 no_argument, NULL, 0 },
 184     { "hash",           required_argument, NULL, 0 },
 185     { "no-strong-intra-smoothing", no_argument, NULL, 0 },
 186     { "strong-intra-smoothing",    no_argument, NULL, 0 },
 187     { "no-cutree",                 no_argument, NULL, 0 },
 188     { "cutree",                    no_argument, NULL, 0 },
 189     { "no-hrd",               no_argument, NULL, 0 },
 190     { "hrd",                  no_argument, NULL, 0 },
 191     { "sar",            required_argument, NULL, 0 },
 192     { "overscan",       required_argument, NULL, 0 },
 193     { "videoformat",    required_argument, NULL, 0 },
 194     { "range",          required_argument, NULL, 0 },
 195     { "colorprim",      required_argument, NULL, 0 },
 196     { "transfer",       required_argument, NULL, 0 },
 197     { "colormatrix",    required_argument, NULL, 0 },
 198     { "chromaloc",      required_argument, NULL, 0 },
 199     { "crop-rect",      required_argument, NULL, 0 },
 200     { "no-dither",            no_argument, NULL, 0 },
 201     { "dither",               no_argument, NULL, 0 },
 202     { "no-repeat-headers",    no_argument, NULL, 0 },
 203     { "repeat-headers",       no_argument, NULL, 0 },
 204     { "aud",                  no_argument, NULL, 0 },
 205     { "no-aud",               no_argument, NULL, 0 },
 206     { "info",                 no_argument, NULL, 0 },
 207     { "no-info",              no_argument, NULL, 0 },
 208     { "qpfile",         required_argument, NULL, 0 },
 209     { "lambda-file",    required_argument, NULL, 0 },
 210     { "b-intra",              no_argument, NULL, 0 },
 211     { "no-b-intra",           no_argument, NULL, 0 },
 212     { "nr-intra",       required_argument, NULL, 0 },
 213     { "nr-inter",       required_argument, NULL, 0 },
 214     { "stats",          required_argument, NULL, 0 },
 215     { "pass",           required_argument, NULL, 0 },
 216     { "slow-firstpass",       no_argument, NULL, 0 },
 217     { "no-slow-firstpass",    no_argument, NULL, 0 },
 218     { "analysis-mode",  required_argument, NULL, 0 },
 219     { "analysis-file",  required_argument, NULL, 0 },
 220     { 0, 0, 0, 0 }
 221 };
 222
 223 /* Ctrl-C handler */
 224 static volatile sig_atomic_t b_ctrl_c /* = 0 */;
 225 static void sigint_handler(int)
 226 {
 227     b_ctrl_c = 1;
 228 }
 229
 230 struct CLIOptions
 231 {
 232     Input*  input;
 233     Output* recon;
 234     std::fstream bitstreamFile;
 235     bool bProgress;
 236     bool bForceY4m;
 237     bool bDither;
 238
 239     uint32_t seek;              // number of frames to skip from the beginning
 240     uint32_t framesToBeEncoded; // number of frames to encode
 241     uint64_t totalbytes;
 242     size_t   analysisRecordSize; // number of bytes read from or dumped into file
 243     int      analysisHeaderSize;
 244
 245     int64_t startTime;
 246     int64_t prevUpdateTime;
 247     float   frameRate;
 248     FILE*   qpfile;
 249     FILE*   analysisFile;
 250
 251     /* in microseconds */
 252     static const int UPDATE_INTERVAL = 250000;
 253
 254     CLIOptions()
 255     {
 256         input = NULL;
 257         recon = NULL;
 258         framesToBeEncoded = seek = 0;
 259         totalbytes = 0;
 260         bProgress = true;
 261         bForceY4m = false;
 262         startTime = x265_mdate();
 263         prevUpdateTime = 0;
 264         bDither = false;
 265         qpfile = NULL;
 266         analysisFile = NULL;
 267         analysisRecordSize = 0;
 268         analysisHeaderSize = 0;
 269     }
 270
 271     void destroy();
 272     void writeNALs(const x265_nal* nal, uint32_t nalcount);
 273     void printStatus(uint32_t frameNum, x265_param *param);
 274     void printVersion(x265_param *param);
 275     void showHelp(x265_param *param);
 276     bool parse(int argc, char **argv, x265_param* param);
 277     bool parseQPFile(x265_picture &pic_org);
 278     bool validateFanout(x265_param*);
 279 };
 280
 281 void CLIOptions::destroy()
 282 {
 283     if (input)
 284         input->release();
 285     input = NULL;
 286     if (recon)
 287         recon->release();
 288     recon = NULL;
 289     if (qpfile)
 290         fclose(qpfile);
 291     qpfile = NULL;
 292     if (analysisFile)
 293         fclose(analysisFile);
 294     analysisFile = NULL;
 295 }
 296
 297 void CLIOptions::writeNALs(const x265_nal* nal, uint32_t nalcount)
 298 {
 299     ProfileScopeEvent(bitstreamWrite);
 300     for (uint32_t i = 0; i < nalcount; i++)
 301     {
 302         bitstreamFile.write((const char*)nal->payload, nal->sizeBytes);
 303         totalbytes += nal->sizeBytes;
 304         nal++;
 305     }
 306 }
 307
 308 void CLIOptions::printStatus(uint32_t frameNum, x265_param *param)
 309 {
 310     char buf[200];
 311     int64_t time = x265_mdate();
 312
 313     if (!bProgress || !frameNum || (prevUpdateTime && time - prevUpdateTime < UPDATE_INTERVAL))
 314         return;
 315     int64_t elapsed = time - startTime;
 316     double fps = elapsed > 0 ? frameNum * 1000000. / elapsed : 0;
 317     float bitrate = 0.008f * totalbytes * (param->fpsNum / param->fpsDenom) / ((float)frameNum);
 318     if (framesToBeEncoded)
 319     {
 320         int eta = (int)(elapsed * (framesToBeEncoded - frameNum) / ((int64_t)frameNum * 1000000));
 321         sprintf(buf, "x265 [%.1f%%] %d/%d frames, %.2f fps, %.2f kb/s, eta %d:%02d:%02d",
 322                 100. * frameNum / framesToBeEncoded, frameNum, framesToBeEncoded, fps, bitrate,
 323                 eta / 3600, (eta / 60) % 60, eta % 60);
 324     }
 325     else
 326     {
 327         sprintf(buf, "x265 %d frames: %.2f fps, %.2f kb/s", frameNum, fps, bitrate);
 328     }
 329     fprintf(stderr, "%s  \r", buf + 5);
 330     SetConsoleTitle(buf);
 331     fflush(stderr); // needed in windows
 332     prevUpdateTime = time;
 333 }
 334
 335 void CLIOptions::printVersion(x265_param *param)
 336 {
 337     x265_log(param, X265_LOG_INFO, "HEVC encoder version %s\n", x265_version_str);
 338     x265_log(param, X265_LOG_INFO, "build info %s\n", x265_build_info_str);
 339 }
 340
 341 void CLIOptions::showHelp(x265_param *param)
 342 {
 343     int level = param->logLevel;
 344     x265_param_default(param);
 345     printVersion(param);
 346
 347 #define OPT(value) (value ? "enabled" : "disabled")
 348 #define H0 printf
 349 #define H1 if (level >= X265_LOG_DEBUG) printf
 350
 351     H0("\nSyntax: x265 [options] infile [-o] outfile\n");
 352     H0("    infile can be YUV or Y4M\n");
 353     H0("    outfile is raw HEVC bitstream\n");
 354     H0("\nExecutable Options:\n");
 355     H0("-h/--help                        Show this help text and exit\n");
 356     H0("-V/--version                     Show version info and exit\n");
 357     H0("\nOutput Options:\n");
 358     H0("-o/--output <filename>           Bitstream output file name\n");
 359     H0("   --log-level <string>          Logging level: none error warning info debug full. Default %s\n", logLevelNames[param->logLevel + 1]);
 360     H0("   --no-progress                 Disable CLI progress reports\n");
 361     H0("   --[no-]cu-stats               Enable logging stats about distribution of cu across all modes. Default %s\n",OPT(param->bLogCuStats));
 362     H1("   --csv <filename>              Comma separated log file, log level >= 3 frame log, else one line per run\n");
 363     H0("\nInput Options:\n");
 364     H0("   --input <filename>            Raw YUV or Y4M input file name. `-` for stdin\n");
 365     H1("   --y4m                         Force parsing of input stream as YUV4MPEG2 regardless of file extension\n");
 366     H0("   --fps <float|rational>        Source frame rate (float or num/denom), auto-detected if Y4M\n");
 367     H0("   --input-res WxH               Source picture size [w x h], auto-detected if Y4M\n");
 368     H1("   --input-depth <integer>       Bit-depth of input file. Default 8\n");
 369     H1("   --input-csp <string>          Source color space: i420, i444 or i422, auto-detected if Y4M. Default: i420\n");
 370     H0("-f/--frames <integer>            Maximum number of frames to encode. Default all\n");
 371     H0("   --seek <integer>              First frame to encode\n");
 372     H1("   --[no-]interlace <bff|tff>    Indicate input pictures are interlace fields in temporal order. Default progressive\n");
 373     H1("   --dither                      Enable dither if downscaling to 8 bit pixels. Default disabled\n");
 374     H0("\nQuality reporting metrics:\n");
 375     H0("   --[no-]ssim                   Enable reporting SSIM metric scores. Default %s\n", OPT(param->bEnableSsim));
 376     H0("   --[no-]psnr                   Enable reporting PSNR metric scores. Default %s\n", OPT(param->bEnablePsnr));
 377     H0("\nProfile, Level, Tier:\n");
 378     H0("   --profile <string>            Enforce an encode profile: main, main10, mainstillpicture\n");
 379     H0("   --level-idc <integer|float>   Force a minumum required decoder level (as '5.0' or '50')\n");
 380     H0("   --[no-]high-tier              If a decoder level is specified, this modifier selects High tier of that level\n");
 381     H0("\nThreading, performance:\n");
 382     H0("   --threads <integer>           Number of threads for thread pool (0: detect CPU core count, default)\n");
 383     H0("-F/--frame-threads <integer>     Number of concurrently encoded frames. 0: auto-determined by core count\n");
 384     H0("   --[no-]wpp                    Enable Wavefront Parallel Processing. Default %s\n", OPT(param->bEnableWavefront));
 385     H0("   --[no-]pmode                  Parallel mode analysis. Default %s\n", OPT(param->bDistributeModeAnalysis));
 386     H0("   --[no-]pme                    Parallel motion estimation. Default %s\n", OPT(param->bDistributeMotionEstimation));
 387     H0("   --[no-]asm <bool|int|string>  Override CPU detection. Default: auto\n");
 388     H0("\nPresets:\n");
 389     H0("-p/--preset <string>             Trade off performance for compression efficiency. Default medium\n");
 390     H0("                                 ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow, or placebo\n");
 391     H0("-t/--tune <string>               Tune the settings for a particular type of source or situation:\n");
 392     H0("                                 psnr, ssim, grain, zerolatency, fastdecode or cbr\n");
 393     H0("\nQuad-Tree size and depth:\n");
 394     H0("-s/--ctu <64|32|16>              Maximum CU size (WxH). Default %d\n", param->maxCUSize);
 395     H0("   --tu-intra-depth <integer>    Max TU recursive depth for intra CUs. Default %d\n", param->tuQTMaxIntraDepth);
 396     H0("   --tu-inter-depth <integer>    Max TU recursive depth for inter CUs. Default %d\n", param->tuQTMaxInterDepth);
 397     H0("\nAnalysis:\n");
 398     H0("   --rd <0..6>                   Level of RD in mode decision 0:least....6:full RDO. Default %d\n", param->rdLevel);
 399     H0("   --psy-rd <0..2.0>             Strength of psycho-visual rate distortion optimization, 0 to disable. Default %.1f\n", param->psyRd);
 400     H0("   --psy-rdoq <0..50.0>          Strength of psycho-visual optimization in quantization, 0 to disable. Default %.1f\n", param->psyRdoq);
 401     H0("   --[no-]early-skip             Enable early SKIP detection. Default %s\n", OPT(param->bEnableEarlySkip));
 402     H1("   --[no-]fast-cbf               Enable early outs based on whether residual is coded. Default %s\n", OPT(param->bEnableCbfFastMode));
 403     H1("   --[no-]tskip-fast             Enable fast intra transform skipping. Default %s\n", OPT(param->bEnableTSkipFast));
 404     H1("   --nr-intra <integer>          An integer value in range of 0 to 2000, which denotes strength of noise reduction in intra CUs. Default 0\n");
 405     H1("   --nr-inter <integer>          An integer value in range of 0 to 2000, which denotes strength of noise reduction in inter CUs. Default 0\n");
 406     H0("\nCoding tools:\n");
 407     H0("-w/--[no-]weightp                Enable weighted prediction in P slices. Default %s\n", OPT(param->bEnableWeightedPred));
 408     H0("   --[no-]weightb                Enable weighted prediction in B slices. Default %s\n", OPT(param->bEnableWeightedBiPred));
 409     H0("   --[no-]cu-lossless            Consider lossless mode in CU RDO decisions. Default %s\n", OPT(param->bCULossless));
 410     H0("   --[no-]signhide               Hide sign bit of one coeff per TU (rdo). Default %s\n", OPT(param->bEnableSignHiding));
 411     H1("   --[no-]tskip                  Enable intra 4x4 transform skipping. Default %s\n", OPT(param->bEnableTransformSkip));
 412     H0("\nTemporal / motion search options:\n");
 413     H0("   --me <string>                 Motion search method dia hex umh star full. Default %d\n", param->searchMethod);
 414     H0("-m/--subme <integer>             Amount of subpel refinement to perform (0:least .. 7:most). Default %d \n", param->subpelRefine);
 415     H0("   --merange <integer>           Motion search range. Default %d\n", param->searchRange);
 416     H0("   --max-merge <1..5>            Maximum number of merge candidates. Default %d\n", param->maxNumMergeCand);
 417     H0("   --[no-]rect                   Enable rectangular motion partitions Nx2N and 2NxN. Default %s\n", OPT(param->bEnableRectInter));
 418     H0("   --[no-]amp                    Enable asymmetric motion partitions, requires --rect. Default %s\n", OPT(param->bEnableAMP));
 419     H1("   --[no-]temporal-mvp           Enable temporal MV predictors. Default %s\n", OPT(param->bEnableTemporalMvp));
 420     H0("\nSpatial / intra options:\n");
 421     H0("   --[no-]strong-intra-smoothing Enable strong intra smoothing for 32x32 blocks. Default %s\n", OPT(param->bEnableStrongIntraSmoothing));
 422     H0("   --[no-]constrained-intra      Constrained intra prediction (use only intra coded reference pixels) Default %s\n", OPT(param->bEnableConstrainedIntra));
 423     H0("   --[no-]b-intra                Enable intra in B frames in veryslow presets. Default %s\n", OPT(param->bIntraInBFrames));
 424     H0("   --[no-]fast-intra             Enable faster search method for angular intra predictions. Default %s\n", OPT(param->bEnableFastIntra));
 425     H0("   --rdpenalty <0..2>            penalty for 32x32 intra TU in non-I slices. 0:disabled 1:RD-penalty 2:maximum. Default %d\n", param->rdPenalty);
 426     H0("\nSlice decision options:\n");
 427     H0("   --[no-]open-gop               Enable open-GOP, allows I slices to be non-IDR. Default %s\n", OPT(param->bOpenGOP));
 428     H0("-I/--keyint <integer>            Max IDR period in frames. -1 for infinite-gop. Default %d\n", param->keyframeMax);
 429     H0("-i/--min-keyint <integer>        Scenecuts closer together than this are coded as I, not IDR. Default: auto\n");
 430     H0("   --no-scenecut                 Disable adaptive I-frame decision\n");
 431     H0("   --scenecut <integer>          How aggressively to insert extra I-frames. Default %d\n", param->scenecutThreshold);
 432     H0("   --rc-lookahead <integer>      Number of frames for frame-type lookahead (determines encoder latency) Default %d\n", param->lookaheadDepth);
 433     H0("   --bframes <integer>           Maximum number of consecutive b-frames (now it only enables B GOP structure) Default %d\n", param->bframes);
 434     H1("   --bframe-bias <integer>       Bias towards B frame decisions. Default %d\n", param->bFrameBias);
 435     H0("   --b-adapt <0..2>              0 - none, 1 - fast, 2 - full (trellis) adaptive B frame scheduling. Default %d\n", param->bFrameAdaptive);
 436     H0("   --[no-]b-pyramid              Use B-frames as references. Default %s\n", OPT(param->bBPyramid));
 437     H0("   --ref <integer>               max number of L0 references to be allowed (1 .. 16) Default %d\n", param->maxNumReferences);
 438     H1("   --qpfile <string>             Force frametypes and QPs for some or all frames\n");
 439     H1("                                 Format of each line: framenumber frametype QP\n");
 440     H1("                                 QP is optional (none lets x265 choose). Frametypes: I,i,P,B,b.\n");
 441     H1("                                 QPs are restricted by qpmin/qpmax.\n");
 442     H0("\nRate control, Adaptive Quantization:\n");
 443     H0("   --bitrate <integer>           Target bitrate (kbps) for ABR (implied). Default %d\n", param->rc.bitrate);
 444     H1("-q/--qp <integer>                QP for P slices in CQP mode (implied). --ipratio and --pbration determine other slice QPs\n");
 445     H0("   --crf <float>                 Quality-based VBR (0-51). Default %.1f\n", param->rc.rfConstant);
 446     H1("   --[no-]lossless               Enable lossless: bypass transform, quant and loop filters globally. Default %s\n", OPT(param->bLossless));
 447     H1("   --crf-max <float>             With CRF+VBV, limit RF to this value. Default %f\n", param->rc.rfConstantMax);
 448     H1("                                 May cause VBV underflows!\n");
 449     H1("   --crf-min <float>             With CRF+VBV, limit RF to this value. Default %f\n", param->rc.rfConstantMin);
 450     H1("                                 this specifies a minimum rate factor value for encode!\n");
 451     H0("   --vbv-maxrate <integer>       Max local bitrate (kbit/s). Default %d\n", param->rc.vbvMaxBitrate);
 452     H0("   --vbv-bufsize <integer>       Set size of the VBV buffer (kbit). Default %d\n", param->rc.vbvBufferSize);
 453     H0("   --vbv-init <float>            Initial VBV buffer occupancy (fraction of bufsize or in kbits). Default %.2f\n", param->rc.vbvBufferInit);
 454     H0("   --pass                        Multi pass rate control.\n"
 455        "                                   - 1 : First pass, creates stats file\n"
 456        "                                   - 2 : Last pass, does not overwrite stats file\n"
 457        "                                   - 3 : Nth pass, overwrites stats file\n");
 458     H0("   --stats                       Filename for stats file in multipass pass rate control. Default x265_2pass.log\n");
 459     H0("   --[no-]slow-firstpass         Enable a slow first pass in a multipass rate control mode. Default %s\n", OPT(param->rc.bEnableSlowFirstPass));
 460     H0("   --analysis-mode <string|int>  save - Dump analysis info into file, load - Load analysis buffers from the file. Default %d\n", param->analysisMode);
 461     H0("   --analysis-file <filename>    Specify file name used for either dumping or reading analysis data.\n");
 462     H0("   --aq-mode <integer>           Mode for Adaptive Quantization - 0:none 1:uniform AQ 2:auto variance. Default %d\n", param->rc.aqMode);
 463     H0("   --aq-strength <float>         Reduces blocking and blurring in flat and textured areas (0 to 3.0). Default %.2f\n", param->rc.aqStrength);
 464     H0("   --[no-]cutree                 Enable cutree for Adaptive Quantization. Default %s\n", OPT(param->rc.cuTree));
 465     H1("   --ipratio <float>             QP factor between I and P. Default %.2f\n", param->rc.ipFactor);
 466     H1("   --pbratio <float>             QP factor between P and B. Default %.2f\n", param->rc.pbFactor);
 467     H1("   --qcomp <float>               Weight given to predicted complexity. Default %.2f\n", param->rc.qCompress);
 468     H1("   --ratetol <float>             Degree of rate fluctuation that can be tolerated. Default %.2f\n", param->rc.rateTolerance);
 469     H1("   --cbqpoffs <integer>          Chroma Cb QP Offset. Default %d\n", param->cbQpOffset);
 470     H1("   --crqpoffs <integer>          Chroma Cr QP Offset. Default %d\n", param->crQpOffset);
 471     H1("   --scaling-list <string>       Specify a file containing HM style quant scaling lists or 'default' or 'off'. Default: off\n");
 472     H1("   --lambda-file <string>        Specify a file containing replacement values for the lambda tables\n");
 473     H1("                                 MAX_MAX_QP+1 floats for lambda table, then again for lambda2 table\n");
 474     H1("                                 Blank lines and lines starting with hash(#) are ignored\n");
 475     H1("                                 Comma is considered to be white-space\n");
 476     H0("\nLoop filters (deblock and SAO):\n");
 477     H0("   --[no-]deblock                Enable Deblocking Loop Filter, optionally specify tC:Beta offsets Default %s\n", OPT(param->bEnableLoopFilter));
 478     H0("   --[no-]sao                    Enable Sample Adaptive Offset. Default %s\n", OPT(param->bEnableSAO));
 479     H1("   --[no-]sao-non-deblock        Use non-deblocked pixels, else right/bottom boundary areas skipped. Default %s\n", OPT(param->bSaoNonDeblocked));
 480     H0("\nVUI options:\n");
 481     H0("   --sar <width:height|int>      Sample Aspect Ratio, the ratio of width to height of an individual pixel.\n");
 482     H0("                                 Choose from 0=undef, 1=1:1(\"square\"), 2=12:11, 3=10:11, 4=16:11,\n");
 483     H0("                                 5=40:33, 6=24:11, 7=20:11, 8=32:11, 9=80:33, 10=18:11, 11=15:11,\n");
 484     H0("                                 12=64:33, 13=160:99, 14=4:3, 15=3:2, 16=2:1 or custom ratio of <int:int>. Default %d\n", param->vui.aspectRatioIdc);
 485     H1("   --crop-rect <string>          Add 'left,top,right,bottom' to the bitstream-level cropping rectangle\n");
 486     H1("   --overscan <string>           Specify whether it is appropriate for decoder to show cropped region: undef, show or crop. Default undef\n");
 487     H0("   --videoformat <string>        Specify video format from undef, component, pal, ntsc, secam, mac. Default undef\n");
 488     H0("   --range <string>              Specify black level and range of luma and chroma signals as full or limited Default limited\n");
 489     H0("   --colorprim <string>          Specify color primaries from undef, bt709, bt470m, bt470bg, smpte170m,\n");
 490     H0("                                 smpte240m, film, bt2020. Default undef\n");
 491     H0("   --transfer <string>           Specify transfer characteristics from undef, bt709, bt470m, bt470bg, smpte170m,\n");
 492     H0("                                 smpte240m, linear, log100, log316, iec61966-2-4, bt1361e, iec61966-2-1,\n");
 493     H0("                                 bt2020-10, bt2020-12. Default undef\n");
 494     H1("   --colormatrix <string>        Specify color matrix setting from undef, bt709, fcc, bt470bg, smpte170m,\n");
 495     H1("                                 smpte240m, GBR, YCgCo, bt2020nc, bt2020c. Default undef\n");
 496     H1("   --chromaloc <integer>         Specify chroma sample location (0 to 5). Default of %d\n", param->vui.chromaSampleLocTypeTopField);
 497     H0("\nBitstream options:\n");
 498     H0("   --[no-]info                   Emit SEI identifying encoder and parameters. Default %s\n", OPT(param->bEmitInfoSEI));
 499     H0("   --[no-]aud                    Emit access unit delimiters at the start of each access unit. Default %s\n", OPT(param->bEnableAccessUnitDelimiters));
 500     H0("   --[no-]hrd                    Enable HRD parameters signaling. Default %s\n", OPT(param->bEmitHRDSEI));
 501     H0("   --[no-]repeat-headers         Emit SPS and PPS headers at each keyframe. Default %s\n", OPT(param->bRepeatHeaders));
 502     H1("   --hash <integer>              Decoded Picture Hash SEI 0: disabled, 1: MD5, 2: CRC, 3: Checksum. Default %d\n", param->decodedPictureHashSEI);
 503     H1("\nReconstructed video options (debugging):\n");
 504     H1("-r/--recon <filename>            Reconstructed raw image YUV or Y4M output file name\n");
 505     H1("   --recon-depth <integer>       Bit-depth of reconstructed raw image file. Defaults to input bit depth, or 8 if Y4M\n");
 506 #undef OPT
 507 #undef H0
 508 #undef H1
 509
 510     if (level < X265_LOG_DEBUG)
 511         printf("\nUse --log-level full --help for a full listing\n");
 512     printf("\n\nComplete documentation may be found at http://x265.readthedocs.org/en/default/cli.html\n");
 513     exit(0);
 514 }
 515
 516 bool CLIOptions::parse(int argc, char **argv, x265_param* param)
 517 {
 518     bool bError = 0;
 519     int help = 0;
 520     int inputBitDepth = 8;
 521     int reconFileBitDepth = 0;
 522     const char *inputfn = NULL;
 523     const char *reconfn = NULL;
 524     const char *bitstreamfn = NULL;
 525     const char *preset = NULL;
 526     const char *tune = NULL;
 527     const char *profile = NULL;
 528
 529     if (argc <= 1)
 530     {
 531         x265_log(NULL, X265_LOG_ERROR, "No input file. Run x265 --help for a list of options.\n");
 532         return true;
 533     }
 534
 535     /* Presets are applied before all other options. */
 536     for (optind = 0;; )
 537     {
 538         int c = getopt_long(argc, argv, short_options, long_options, NULL);
 539         if (c == -1)
 540             break;
 541         if (c == 'p')
 542             preset = optarg;
 543         if (c == 't')
 544             tune = optarg;
 545         else if (c == '?')
 546             showHelp(param);
 547     }
 548
 549     if (x265_param_default_preset(param, preset, tune) < 0)
 550     {
 551         x265_log(NULL, X265_LOG_ERROR, "preset or tune unrecognized\n");
 552         return true;
 553     }
 554
 555     for (optind = 0;; )
 556     {
 557         int long_options_index = -1;
 558         int c = getopt_long(argc, argv, short_options, long_options, &long_options_index);
 559         if (c == -1)
 560         {
 561             break;
 562         }
 563
 564         switch (c)
 565         {
 566         case 'h':
 567             showHelp(param);
 568             break;
 569
 570         case 'V':
 571             printVersion(param);
 572             x265_setup_primitives(param, -1);
 573             exit(0);
 574
 575         default:
 576             if (long_options_index < 0 && c > 0)
 577             {
 578                 for (size_t i = 0; i < sizeof(long_options) / sizeof(long_options[0]); i++)
 579                 {
 580                     if (long_options[i].val == c)
 581                     {
 582                         long_options_index = (int)i;
 583                         break;
 584                     }
 585                 }
 586
 587                 if (long_options_index < 0)
 588                 {
 589                     /* getopt_long might have already printed an error message */
 590                     if (c != 63)
 591                         x265_log(NULL, X265_LOG_WARNING, "internal error: short option '%c' has no long option\n", c);
 592                     return true;
 593                 }
 594             }
 595             if (long_options_index < 0)
 596             {
 597                 x265_log(NULL, X265_LOG_WARNING, "short option '%c' unrecognized\n", c);
 598                 return true;
 599             }
 600 #define OPT(longname) \
 601     else if (!strcmp(long_options[long_options_index].name, longname))
 602 #define OPT2(name1, name2) \
 603     else if (!strcmp(long_options[long_options_index].name, name1) || \
 604              !strcmp(long_options[long_options_index].name, name2))
 605
 606             if (0) ;
 607             OPT2("frame-skip", "seek") this->seek = (uint32_t)x265_atoi(optarg, bError);
 608             OPT("frames") this->framesToBeEncoded = (uint32_t)x265_atoi(optarg, bError);
 609             OPT("no-progress") this->bProgress = false;
 610             OPT("output") bitstreamfn = optarg;
 611             OPT("input") inputfn = optarg;
 612             OPT("recon") reconfn = optarg;
 613             OPT("input-depth") inputBitDepth = (uint32_t)x265_atoi(optarg, bError);
 614             OPT("dither") this->bDither = true;
 615             OPT("recon-depth") reconFileBitDepth = (uint32_t)x265_atoi(optarg, bError);
 616             OPT("y4m") this->bForceY4m = true;
 617             OPT("profile") profile = optarg; /* handled last */
 618             OPT("preset") /* handled above */;
 619             OPT("tune")   /* handled above */;
 620             OPT("qpfile")
 621             {
 622                 this->qpfile = fopen(optarg, "rb");
 623                 if (!this->qpfile)
 624                 {
 625                     x265_log(param, X265_LOG_ERROR, "%s qpfile not found or error in opening qp file \n", optarg);
 626                     return false;
 627                 }
 628             }
 629             else
 630                 bError |= !!x265_param_parse(param, long_options[long_options_index].name, optarg);
 631
 632             if (bError)
 633             {
 634                 const char *name = long_options_index > 0 ? long_options[long_options_index].name : argv[optind - 2];
 635                 x265_log(NULL, X265_LOG_ERROR, "invalid argument: %s = %s\n", name, optarg);
 636                 return true;
 637             }
 638 #undef OPT
 639         }
 640     }
 641
 642     if (optind < argc && !inputfn)
 643         inputfn = argv[optind++];
 644     if (optind < argc && !bitstreamfn)
 645         bitstreamfn = argv[optind++];
 646     if (optind < argc)
 647     {
 648         x265_log(param, X265_LOG_WARNING, "extra unused command arguments given <%s>\n", argv[optind]);
 649         return true;
 650     }
 651
 652     if (argc <= 1 || help)
 653         showHelp(param);
 654
 655     if (inputfn == NULL || bitstreamfn == NULL)
 656     {
 657         x265_log(param, X265_LOG_ERROR, "input or output file not specified, try -V for help\n");
 658         return true;
 659     }
 660
 661 #if HIGH_BIT_DEPTH
 662     if (param->internalBitDepth != 10)
 663     {
 664         x265_log(param, X265_LOG_ERROR, "Only bit depths of 10 are supported in this build\n");
 665         return true;
 666     }
 667 #else
 668     if (param->internalBitDepth != 8)
 669     {
 670         x265_log(param, X265_LOG_ERROR, "Only bit depths of 8 are supported in this build\n");
 671         return true;
 672     }
 673 #endif // if HIGH_BIT_DEPTH
 674
 675     InputFileInfo info;
 676     info.filename = inputfn;
 677     info.depth = inputBitDepth;
 678     info.csp = param->internalCsp;
 679     info.width = param->sourceWidth;
 680     info.height = param->sourceHeight;
 681     info.fpsNum = param->fpsNum;
 682     info.fpsDenom = param->fpsDenom;
 683     info.sarWidth = param->vui.sarWidth;
 684     info.sarHeight = param->vui.sarHeight;
 685     info.skipFrames = seek;
 686     info.frameCount = 0;
 687     getParamAspectRatio(param, info.sarWidth, info.sarHeight);
 688
 689     this->input = Input::open(info, this->bForceY4m);
 690     if (!this->input || this->input->isFail())
 691     {
 692         x265_log(param, X265_LOG_ERROR, "unable to open input file <%s>\n", inputfn);
 693         return true;
 694     }
 695
 696     if (info.depth < 8 || info.depth > 16)
 697     {
 698         x265_log(param, X265_LOG_ERROR, "Input bit depth (%d) must be between 8 and 16\n", inputBitDepth);
 699         return true;
 700     }
 701
 702     /* Unconditionally accept height/width/csp from file info */
 703     param->sourceWidth = info.width;
 704     param->sourceHeight = info.height;
 705     param->internalCsp = info.csp;
 706
 707     /* Accept fps and sar from file info if not specified by user */
 708     if (param->fpsDenom == 0 || param->fpsNum == 0)
 709     {
 710         param->fpsDenom = info.fpsDenom;
 711         param->fpsNum = info.fpsNum;
 712     }
 713     if (!param->vui.aspectRatioIdc && info.sarWidth && info.sarHeight)
 714         setParamAspectRatio(param, info.sarWidth, info.sarHeight);
 715     if (this->framesToBeEncoded == 0 && info.frameCount > (int)seek)
 716         this->framesToBeEncoded = info.frameCount - seek;
 717     param->totalFrames = this->framesToBeEncoded;
 718
 719     if (x265_param_apply_profile(param, profile))
 720         return true;
 721
 722     if (param->logLevel >= X265_LOG_INFO)
 723     {
 724         char buf[128];
 725         int p = sprintf(buf, "%dx%d fps %d/%d %sp%d", param->sourceWidth, param->sourceHeight,
 726                         param->fpsNum, param->fpsDenom, x265_source_csp_names[param->internalCsp], info.depth);
 727
 728         int width, height;
 729         getParamAspectRatio(param, width, height);
 730         if (width && height)
 731             p += sprintf(buf + p, " sar %d:%d", width, height);
 732
 733         if (framesToBeEncoded <= 0 || info.frameCount <= 0)
 734             strcpy(buf + p, " unknown frame count");
 735         else
 736             sprintf(buf + p, " frames %u - %d of %d", this->seek, this->seek + this->framesToBeEncoded - 1, info.frameCount);
 737
 738         fprintf(stderr, "%s  [info]: %s\n", input->getName(), buf);
 739     }
 740
 741     this->input->startReader();
 742
 743     if (reconfn)
 744     {
 745         if (reconFileBitDepth == 0)
 746             reconFileBitDepth = param->internalBitDepth;
 747         this->recon = Output::open(reconfn, param->sourceWidth, param->sourceHeight, reconFileBitDepth,
 748                                    param->fpsNum, param->fpsDenom, param->internalCsp);
 749         if (this->recon->isFail())
 750         {
 751             x265_log(param, X265_LOG_WARNING, "unable to write reconstruction file\n");
 752             this->recon->release();
 753             this->recon = 0;
 754         }
 755         else
 756             fprintf(stderr, "%s  [info]: reconstructed images %dx%d fps %d/%d %s\n", this->recon->getName(),
 757                     param->sourceWidth, param->sourceHeight, param->fpsNum, param->fpsDenom,
 758                     x265_source_csp_names[param->internalCsp]);
 759     }
 760
 761     this->bitstreamFile.open(bitstreamfn, std::fstream::binary | std::fstream::out);
 762     if (!this->bitstreamFile)
 763     {
 764         x265_log(NULL, X265_LOG_ERROR, "failed to open bitstream file <%s> for writing\n", bitstreamfn);
 765         return true;
 766     }
 767     return false;
 768 }
 769
 770 bool CLIOptions::parseQPFile(x265_picture &pic_org)
 771 {
 772     int32_t num = -1, qp, ret;
 773     char type;
 774     uint32_t filePos;
 775     pic_org.forceqp = 0;
 776     pic_org.sliceType = X265_TYPE_AUTO;
 777     while (num < pic_org.poc)
 778     {
 779         filePos = ftell(qpfile);
 780         qp = -1;
 781         ret = fscanf(qpfile, "%d %c%*[ \t]%d\n", &num, &type, &qp);
 782
 783         if (num > pic_org.poc || ret == EOF)
 784         {
 785             fseek(qpfile, filePos, SEEK_SET);
 786             break;
 787         }
 788         if (num < pic_org.poc && ret >= 2)
 789             continue;
 790         if (ret == 3 && qp >= 0)
 791             pic_org.forceqp = qp + 1;
 792         if (type == 'I') pic_org.sliceType = X265_TYPE_IDR;
 793         else if (type == 'i') pic_org.sliceType = X265_TYPE_I;
 794         else if (type == 'P') pic_org.sliceType = X265_TYPE_P;
 795         else if (type == 'B') pic_org.sliceType = X265_TYPE_BREF;
 796         else if (type == 'b') pic_org.sliceType = X265_TYPE_B;
 797         else ret = 0;
 798         if (ret < 2 || qp < -1 || qp > 51)
 799             return 0;
 800     }
 801     return 1;
 802 }
 803
 804 int main(int argc, char **argv)
 805 {
 806 #if HAVE_VLD
 807     // This uses Microsoft's proprietary WCHAR type, but this only builds on Windows to start with
 808     VLDSetReportOptions(VLD_OPT_REPORT_TO_DEBUGGER | VLD_OPT_REPORT_TO_FILE, L"x265_leaks.txt");
 809 #endif
 810     PROFILE_INIT();
 811
 812     x265_param *param = x265_param_alloc();
 813     CLIOptions cliopt;
 814
 815     if (cliopt.parse(argc, argv, param))
 816     {
 817         cliopt.destroy();
 818         x265_param_free(param);
 819         exit(1);
 820     }
 821
 822     x265_encoder *encoder = x265_encoder_open(param);
 823     if (!encoder)
 824     {
 825         x265_log(param, X265_LOG_ERROR, "failed to open encoder\n");
 826         cliopt.destroy();
 827         x265_param_free(param);
 828         x265_cleanup();
 829         exit(1);
 830     }
 831
 832     /* get the encoder parameters post-initialization */
 833     x265_encoder_parameters(encoder, param);
 834
 835     /* Control-C handler */
 836     if (signal(SIGINT, sigint_handler) == SIG_ERR)
 837         x265_log(param, X265_LOG_ERROR, "Unable to register CTRL+C handler: %s\n", strerror(errno));
 838
 839     x265_picture pic_orig, pic_out;
 840     x265_picture *pic_in = &pic_orig;
 841     /* Allocate recon picture if analysisMode is enabled */
 842     x265_picture *pic_recon = (cliopt.recon || !!param->analysisMode) ? &pic_out : NULL;
 843     uint32_t inFrameCount = 0;
 844     uint32_t outFrameCount = 0;
 845     x265_nal *p_nal;
 846     x265_stats stats;
 847     uint32_t nal;
 848     int16_t *errorBuf = NULL;
 849
 850     if (!param->bRepeatHeaders)
 851     {
 852         if (x265_encoder_headers(encoder, &p_nal, &nal) < 0)
 853         {
 854             x265_log(param, X265_LOG_ERROR, "Failure generating stream headers\n");
 855             goto fail;
 856         }
 857         else
 858             cliopt.writeNALs(p_nal, nal);
 859     }
 860
 861     x265_picture_init(param, pic_in);
 862
 863     if (param->analysisMode)
 864     {
 865         if (param->bDistributeModeAnalysis || param->bDistributeMotionEstimation)
 866         {
 867             x265_log(NULL, X265_LOG_ERROR, "Analysis load/save options incompatible with pmode/pme");
 868             goto fail;
 869         }
 870     }
 871
 872     if (cliopt.bDither)
 873     {
 874         errorBuf = X265_MALLOC(int16_t, param->sourceWidth + 1);
 875         if (errorBuf)
 876             memset(errorBuf, 0, (param->sourceWidth + 1) * sizeof(int16_t));
 877         else
 878             cliopt.bDither = false;
 879     }
 880
 881     // main encoder loop
 882     while (pic_in && !b_ctrl_c)
 883     {
 884         pic_orig.poc = inFrameCount;
 885         if (cliopt.qpfile && !param->rc.bStatRead)
 886         {
 887             if (!cliopt.parseQPFile(pic_orig))
 888             {
 889                 x265_log(NULL, X265_LOG_ERROR, "can't parse qpfile for frame %d\n", pic_in->poc);
 890                 fclose(cliopt.qpfile);
 891                 cliopt.qpfile = NULL;
 892             }
 893         }
 894
 895         if (cliopt.framesToBeEncoded && inFrameCount >= cliopt.framesToBeEncoded)
 896             pic_in = NULL;
 897         else if (cliopt.input->readPicture(pic_orig))
 898             inFrameCount++;
 899         else
 900             pic_in = NULL;
 901
 902         if (pic_in)
 903         {
 904             if (pic_in->bitDepth > X265_DEPTH && cliopt.bDither)
 905             {
 906                 ditherImage(*pic_in, param->sourceWidth, param->sourceHeight, errorBuf, X265_DEPTH);
 907                 pic_in->bitDepth = X265_DEPTH;
 908             }
 909         }
 910
 911         int numEncoded = x265_encoder_encode(encoder, &p_nal, &nal, pic_in, pic_recon);
 912         if (numEncoded < 0)
 913         {
 914             b_ctrl_c = 1;
 915             break;
 916         }
 917         outFrameCount += numEncoded;
 918
 919         if (numEncoded && pic_recon && cliopt.recon)
 920             cliopt.recon->writePicture(pic_out);
 921         if (nal)
 922             cliopt.writeNALs(p_nal, nal);
 923
 924         // Because x265_encoder_encode() lazily encodes entire GOPs, updates are per-GOP
 925         cliopt.printStatus(outFrameCount, param);
 926     }
 927
 928     /* Flush the encoder */
 929     while (!b_ctrl_c)
 930     {
 931         uint32_t numEncoded = x265_encoder_encode(encoder, &p_nal, &nal, NULL, pic_recon);
 932         outFrameCount += numEncoded;
 933         if (numEncoded && pic_recon && cliopt.recon)
 934             cliopt.recon->writePicture(pic_out);
 935         if (nal)
 936             cliopt.writeNALs(p_nal, nal);
 937
 938         cliopt.printStatus(outFrameCount, param);
 939
 940         if (!numEncoded)
 941             break;
 942     }
 943
 944     /* clear progress report */
 945     if (cliopt.bProgress)
 946         fprintf(stderr, "%*s\r", 80, " ");
 947
 948 fail:
 949     x265_encoder_get_stats(encoder, &stats, sizeof(stats));
 950     if (param->csvfn && !b_ctrl_c)
 951         x265_encoder_log(encoder, argc, argv);
 952     x265_encoder_close(encoder);
 953     cliopt.bitstreamFile.close();
 954
 955     if (b_ctrl_c)
 956         fprintf(stderr, "aborted at input frame %d, output frame %d\n",
 957                 cliopt.seek + inFrameCount, stats.encodedPictureCount);
 958
 959     if (stats.encodedPictureCount)
 960     {
 961         printf("\nencoded %d frames in %.2fs (%.2f fps), %.2f kb/s", stats.encodedPictureCount,
 962                stats.elapsedEncodeTime, stats.encodedPictureCount / stats.elapsedEncodeTime, stats.bitrate);
 963
 964         if (param->bEnablePsnr)
 965             printf(", Global PSNR: %.3f", stats.globalPsnr);
 966
 967         if (param->bEnableSsim)
 968             printf(", SSIM Mean Y: %.7f (%6.3f dB)", stats.globalSsim, x265_ssim2dB(stats.globalSsim));
 969
 970         printf("\n");
 971     }
 972     else
 973     {
 974         printf("\nencoded 0 frames\n");
 975     }
 976
 977     x265_cleanup(); /* Free library singletons */
 978
 979     cliopt.destroy();
 980
 981     x265_param_free(param);
 982
 983     X265_FREE(errorBuf);
 984
 985 #if HAVE_VLD
 986     assert(VLDReportLeaks() == 0);
 987 #endif
 988     return 0;
 989 }