mpeg2enc/mpeg2enc.c

   1 /* mpeg2enc.c, main() and parameter file reading                            */
   2
   3 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
   4
   5 /*
   6  * Disclaimer of Warranty
   7  *
   8  * These software programs are available to the user without any license fee or
   9  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10  * any and all warranties, whether express, implied, or statuary, including any
  11  * implied warranties or merchantability or of fitness for a particular
  12  * purpose.  In no event shall the copyright-holder be liable for any
  13  * incidental, punitive, or consequential damages of any kind whatsoever
  14  * arising from the use of these programs.
  15  *
  16  * This disclaimer of warranty extends to the user of these programs and user's
  17  * customers, employees, agents, transferees, successors, and assigns.
  18  *
  19  * The MPEG Software Simulation Group does not represent or warrant that the
  20  * programs furnished hereunder are free of infringement of any third-party
  21  * patents.
  22  *
  23  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24  * are subject to royalty fees to patent holders.  Many of these patents are
  25  * general enough such that they are unavoidable regardless of implementation
  26  * design.
  27  *
  28  */
  29
  30 #define MAX(a,b) ( (a)>(b) ? (a) : (b) )
  31 #include <math.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #define GLOBAL_ /* used by global.h */
  37 #include "config.h"
  38 #include "global.h"
  39
  40 /* private prototypes */
  41 static void init _ANSI_ARGS_((void));
  42 static void readcmdline _ANSI_ARGS_((int argc, char *argv[]));
  43 static void readquantmat _ANSI_ARGS_((void));
  44
  45
  46 // Hack for libdv to remove glib dependancy
  47
  48 void
  49 g_log (const char    *log_domain,
  50        int  log_level,
  51        const char    *format,
  52        ...)
  53 {
  54 }
  55
  56 void
  57 g_logv (const char    *log_domain,
  58        int  log_level,
  59        const char    *format,
  60        ...)
  61 {
  62 }
  63
  64
  65 void mpeg2enc_set_w(int width)
  66 {
  67         horizontal_size = width;
  68 }
  69
  70 void mpeg2enc_set_h(int height)
  71 {
  72         vertical_size = height;
  73 }
  74
  75 void mpeg2enc_set_rate(double rate)
  76 {
  77         input_frame_rate = rate;
  78 }
  79
  80 void mpeg2enc_set_input_buffers(int eof, char *y, char *u, char *v)
  81 {
  82         pthread_mutex_lock(&output_lock);
  83         input_buffer_end = eof;
  84         input_buffer_y = y;
  85         input_buffer_u = u;
  86         input_buffer_v = v;
  87         pthread_mutex_unlock(&input_lock);
  88 // Wait for buffers to get copied before returning.
  89         pthread_mutex_lock(&copy_lock);
  90 }
  91
  92 void mpeg2enc_init_buffers()
  93 {
  94         pthread_mutex_init(&input_lock, 0);
  95         pthread_mutex_init(&output_lock, 0);
  96         pthread_mutex_init(&copy_lock, 0);
  97         pthread_mutex_lock(&input_lock);
  98         pthread_mutex_lock(&copy_lock);
  99         input_buffer_end = 0;
 100 }
 101
 102 int mpeg2enc(int argc, char *argv[])
 103 {
 104         stdin_fd = stdin;
 105
 106         verbose = 1;
 107
 108
 109 /* Read command line */
 110         readcmdline(argc, argv);
 111
 112 /* read quantization matrices */
 113         readquantmat();
 114
 115         if(!strlen(out_path))
 116         {
 117                 fprintf(stderr, "No output file given.\n");
 118         }
 119
 120 /* open output file */
 121         if(!(outfile = fopen(out_path, "wb")))
 122         {
 123       sprintf(errortext,"Couldn't create output file %s", out_path);
 124       error(errortext);
 125         }
 126
 127         init();
 128
 129         if(nframes < 0x7fffffff)
 130                 printf("Frame    Completion    Current bitrate     Predicted file size\n");
 131         putseq();
 132
 133         stop_slice_engines();
 134         stop_motion_engines();
 135         stop_transform_engines();
 136         stop_itransform_engines();
 137
 138         fclose(outfile);
 139         fclose(statfile);
 140
 141         if(qt_file) quicktime_close(qt_file);
 142         if(qt_output) quicktime_close(qt_output);
 143         if(mpeg_file) mpeg3_close(mpeg_file);
 144
 145         if(do_stdin)
 146         {
 147                 fclose(stdin_fd);
 148         }
 149         pthread_mutex_destroy(&input_lock);
 150         pthread_mutex_destroy(&output_lock);
 151         return 0;
 152 }
 153
 154 int HorzMotionCode(int i)
 155 {
 156         if (i < 8)
 157       return 1;
 158         if (i < 16)
 159       return 2;
 160         if (i < 32)
 161       return 3;
 162         if ((i < 64) || (constrparms))
 163       return 4;
 164         if (i < 128)
 165       return 5;
 166         if (i < 256)
 167       return 6;
 168         if ((i < 512) || (level == 10))
 169       return 7;
 170         if ((i < 1024) || (level == 8))
 171       return 8;
 172         if (i < 2048)
 173       return 9;
 174         return 1;
 175 }
 176
 177 int VertMotionCode(int i)
 178 {
 179         if (i < 8)
 180       return 1;
 181         if (i < 16)
 182       return 2;
 183         if (i < 32)
 184       return 3;
 185         if ((i < 64) || (level == 10) || (constrparms))
 186       return 4;
 187         return 5;
 188 }
 189
 190 /*
 191         Wrapper for malloc that allocates pbuffers aligned to the
 192         specified byte boundary and checks for failure.
 193         N.b.  don't try to free the resulting pointers, eh...
 194         BUG:    Of course this won't work if a char * won't fit in an int....
 195 */
 196 static uint8_t *bufalloc( size_t size )
 197 {
 198         char *buf = malloc( size + BUFFER_ALIGN );
 199         int adjust;
 200
 201         if( buf == NULL )
 202         {
 203                 error("malloc failed\n");
 204         }
 205         adjust = BUFFER_ALIGN-((int)buf)%BUFFER_ALIGN;
 206         if( adjust == BUFFER_ALIGN )
 207                 adjust = 0;
 208         return (uint8_t*)(buf+adjust);
 209 }
 210
 211 static void init()
 212 {
 213         int i, n, size;
 214         static int block_count_tab[3] = {6,8,12};
 215         int lum_buffer_size, chrom_buffer_size;
 216         pthread_mutexattr_t mutex_attr;
 217         pthread_mutexattr_init(&mutex_attr);
 218         pthread_mutex_init(&test_lock, &mutex_attr);
 219
 220         bzero(&cur_picture, sizeof(pict_data_s));
 221         mpeg2_initbits();
 222         init_fdct();
 223         init_idct();
 224         init_motion();
 225         init_predict_hv();
 226         init_quantizer_hv();
 227         init_transform_hv();
 228
 229 /* round picture dimensions to nZearest multiple of 16 or 32 */
 230         mb_width = (horizontal_size+15)/16;
 231         mb_height = prog_seq ?
 232                 (vertical_size + 15) / 16 :
 233                 2 * ((vertical_size + 31) / 32);
 234         mb_height2 = fieldpic ?
 235                 mb_height >> 1 :
 236                 mb_height; /* for field pictures */
 237         width = 16 * mb_width;
 238         height = 16 * mb_height;
 239
 240         chrom_width = (chroma_format==CHROMA444) ? width : width>>1;
 241         chrom_height = (chroma_format!=CHROMA420) ? height : height>>1;
 242
 243         height2 = fieldpic ? height>>1 : height;
 244         width2 = fieldpic ? width<<1 : width;
 245         chrom_width2 = fieldpic ? chrom_width<<1 : chrom_width;
 246
 247         block_count = block_count_tab[chroma_format-1];
 248         lum_buffer_size = (width*height) +
 249                                          sizeof(uint8_t) *(width/2)*(height/2) +
 250                                          sizeof(uint8_t) *(width/4)*(height/4+1);
 251         chrom_buffer_size = chrom_width*chrom_height;
 252
 253         fsubsample_offset = (width)*(height) * sizeof(uint8_t);
 254         qsubsample_offset =  fsubsample_offset + (width/2)*(height/2)*sizeof(uint8_t);
 255
 256         rowsums_offset = 0;
 257         colsums_offset = 0;
 258
 259         mb_per_pict = mb_width*mb_height2;
 260
 261 /* clip table */
 262         if (!(clp = (unsigned char *)malloc(1024)))
 263       error("malloc failed\n");
 264         clp+= 384;
 265         for (i=-384; i<640; i++)
 266       clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
 267
 268
 269
 270         /* Allocate the frame buffer */
 271
 272
 273         frame_buffers = (uint8_t ***)
 274                 bufalloc(2*READ_LOOK_AHEAD*sizeof(uint8_t**));
 275
 276         for(n=0;n<2*READ_LOOK_AHEAD;n++)
 277         {
 278          frame_buffers[n] = (uint8_t **) bufalloc(3*sizeof(uint8_t*));
 279                  for (i=0; i<3; i++)
 280                  {
 281                          frame_buffers[n][i] =
 282                                  bufalloc( (i==0) ? lum_buffer_size : chrom_buffer_size );
 283                  }
 284         }
 285
 286
 287
 288         /* TODO: The ref and aux frame buffers are no redundant! */
 289         for( i = 0 ; i<3; i++)
 290         {
 291                 int size =  (i==0) ? lum_buffer_size : chrom_buffer_size;
 292                 newrefframe[i] = bufalloc(size);
 293                 oldrefframe[i] = bufalloc(size);
 294                 auxframe[i]    = bufalloc(size);
 295                 predframe[i]   = bufalloc(size);
 296         }
 297
 298         cur_picture.qblocks =
 299                 (int16_t (*)[64])bufalloc(mb_per_pict*block_count*sizeof(int16_t [64]));
 300
 301         /* Initialise current transformed picture data tables
 302            These will soon become a buffer for transformed picture data to allow
 303            look-ahead for bit allocation etc.
 304          */
 305         cur_picture.mbinfo = (
 306                 struct mbinfo *)bufalloc(mb_per_pict*sizeof(struct mbinfo));
 307
 308         cur_picture.blocks =
 309                 (int16_t (*)[64])bufalloc(mb_per_pict * block_count * sizeof(int16_t [64]));
 310
 311
 312 /* open statistics output file */
 313         if(statname[0]=='-') statfile = stdout;
 314         else
 315         if(!(statfile = fopen(statname,"w")))
 316         {
 317       sprintf(errortext,"Couldn't create statistics output file %s",statname);
 318       error(errortext);
 319         }
 320
 321         ratectl = malloc(processors * sizeof(ratectl_t*));
 322         for(i = 0; i < processors; i++)
 323                 ratectl[i] = calloc(1, sizeof(ratectl_t));
 324
 325
 326
 327 /* Start parallel threads */
 328
 329 //printf("init 1\n");
 330         start_motion_engines();
 331 //printf("init 2\n");
 332         start_transform_engines();
 333 //printf("init 3\n");
 334         start_itransform_engines();
 335 //printf("init 4\n");
 336         start_slice_engines();
 337 //printf("init 5\n");
 338 }
 339
 340 void error(text)
 341 char *text;
 342 {
 343   fprintf(stderr,text);
 344   putc('\n',stderr);
 345   exit(1);
 346 }
 347
 348 #define STRINGLEN 254
 349
 350 int calculate_smp()
 351 {
 352 /* Get processor count */
 353         int result = 1;
 354         FILE *proc;
 355         if(proc = fopen("/proc/cpuinfo", "r"))
 356         {
 357                 char string[1024];
 358                 while(!feof(proc))
 359                 {
 360                         fgets(string, 1024, proc);
 361                         if(!strncasecmp(string, "processor", 9))
 362                         {
 363                                 char *ptr = strchr(string, ':');
 364                                 if(ptr)
 365                                 {
 366                                         ptr++;
 367                                         result = atol(ptr) + 1;
 368                                 }
 369                         }
 370                         else
 371                         if(!strncasecmp(string, "cpus detected", 13))
 372                         {
 373                                 char *ptr = strchr(string, ':');
 374                                 if(ptr)
 375                                 {
 376                                         ptr++;
 377                                         result = atol(ptr);
 378                                 }
 379                         }
 380                 }
 381                 fclose(proc);
 382         }
 383         return result;
 384 }
 385
 386 static void readcmdline(int argc, char *argv[])
 387 {
 388         int i, j;
 389         int h,m,s,f;
 390         FILE *fd;
 391         char line[256];
 392 // Master frame rate table must match decoder
 393         static double ratetab[]=
 394         {24000.0/1001.0,  // Official rates
 395                 24.0,
 396                 25.0,
 397                 30000.0/1001.0,
 398                 30.0,
 399                 50.0,
 400                 60000.0/1001.0,
 401                 60.0,
 402
 403                 1,           // Unofficial economy rates
 404                 5,
 405                 10,
 406                 12,
 407                 15,
 408                 0,
 409                 0};
 410 // VBV buffer size limits
 411         int vbvlim[4] = { 597, 448, 112, 29 };
 412         long total_frame_rates = (sizeof(ratetab) / sizeof(double));
 413         FILE *proc;
 414 // Default 16
 415         int param_searchrad = 16;
 416         int isnum = 1;
 417
 418 //printf("readcmdline 1\n");
 419         frame0 =                   0;  /* number of first frame */
 420         start_frame = end_frame = -1;
 421         use_hires_quant = 0;
 422         use_denoise_quant = 0;
 423         quiet = 1;
 424         bit_rate = 5000000;                       /* default bit_rate (bits/s) */
 425         prog_seq = 0;                        /* progressive_sequence is faster */
 426         mpeg1 = 0;                                   /* ISO/IEC 11172-2 stream */
 427     fixed_mquant = 0;                             /* vary the quantization */
 428         quant_floor = 0;
 429         act_boost = 3.0;
 430         N = 15;                                      /* N (# of frames in GOP) */
 431         M = 1;  /* M (I/P frame distance) */
 432         processors = calculate_smp();
 433         frame_rate = -1;
 434         chroma_format =            1;  /* chroma_format: 1=4:2:0, 2=4:2:2, 3=4:4:4   LibMPEG3 only does 1 */
 435         mpeg_file = 0;
 436         qt_file = 0;
 437         do_stdin = 0;
 438         do_buffers = 1;
 439         seq_header_every_gop = 0;
 440 /* aspect_ratio_information 1=square pel, 2=4:3, 3=16:9, 4=2.11:1 */
 441         aspectratio = 1;
 442
 443
 444
 445
 446
 447 //printf("readcmdline 2\n");
 448
 449
 450         sprintf(tplorg, "");
 451         sprintf(out_path, "");
 452
 453 #define INTTOYES(x) ((x) ? "Yes" : "No")
 454 // This isn't used anymore as this is a library entry point.
 455   if(argc < 2)
 456   {
 457     printf("mpeg2encode V1.3, 2000/01/10\n"
 458 "(C) 1996, MPEG Software Simulation Group\n"
 459 "(C) 2001 Heroine Virtual\n"
 460 "Usage: %s [options] <input file> <output file>\n\n"
 461 " -1                 generate an MPEG-1 stream instead of MPEG-2 (%s)\n"
 462 " -422                                 generate YUV 4:2:2 output\n"
 463 " -b bitrate              fix the bitrate, vary the quantization (%d)\n"
 464 " -d                                                     Denoise (%s)\n"
 465 " -f rate                                      Convert framerate\n"
 466 " -h                          High resolution quantization table (%s)\n"
 467 " -m frames                set number of frames between P frames (%d)\n"
 468 " -n frames                set number of frames between I frames (%d)\n"
 469 " -p                                   encode progressive frames (%s)\n"
 470 " -q quantization         fix the quantization, vary the bitrate\n"
 471 " [number]               Start encoding from frame number to end\n"
 472 " [number1] [number2]    Encode frame number 1 to frame number 2\n"
 473 " -u                                        Use only 1 processor\n\n"
 474 "Default settings:\n"
 475 "   fixed 5000000 bits/sec\n"
 476 "   interlaced\n"
 477 "   MPEG-2\n"
 478 "   15 frames between I frames   0 frames between P frames\n\n"
 479 "For the recommended encoding parameters see docs/index.html.\n",
 480 argv[0],
 481 mpeg1 ? "MPEG-1" : "MPEG-2",
 482 (int)bit_rate,
 483 INTTOYES(use_denoise_quant),
 484 INTTOYES(use_hires_quant),
 485 M - 1,
 486 N,
 487 INTTOYES(prog_seq));
 488     exit(1);
 489   }
 490 //printf("readcmdline 3\n");
 491
 492         for(i = 1; i < argc; i++)
 493         {
 494                 isnum = 1;
 495
 496                 for(j = 0; j < strlen(argv[i]) && isnum; j++)
 497                 {
 498                         if(isalpha(argv[i][j])) isnum = 0;
 499                 }
 500
 501
 502 //printf("readcmdline %s\n", argv[i]);
 503                 if(!strcmp(argv[i], "-1"))
 504                 {
 505                         mpeg1 = 1;
 506                 }
 507                 else
 508                 if(!strcmp(argv[i], "-a"))
 509                 {
 510                         i++;
 511                         if(i < argc)
 512                         {
 513                                 aspectratio = atoi(argv[i]);
 514                         }
 515                         else
 516                         {
 517                                 fprintf(stderr, "-i needs an aspect ratio enumeration.\n");
 518                                 exit(1);
 519                         }
 520                 }
 521                 else
 522                 if(!strcmp(argv[i], "-b"))
 523                 {
 524                         i++;
 525                         if(i < argc)
 526                         {
 527                                 bit_rate = atol(argv[i]);
 528                         }
 529                         else
 530                         {
 531                                 fprintf(stderr, "-b requires a bitrate\n");
 532                                 exit(1);
 533                         }
 534                 }
 535                 else
 536                 if(!strcmp(argv[i], "-d"))
 537                 {
 538                         use_denoise_quant = 1;
 539                 }
 540                 else
 541                 if(!strcmp(argv[i], "-f"))
 542                 {
 543                         i++;
 544                         if(i < argc)
 545                         {
 546                                 frame_rate = atof(argv[i]);
 547                         }
 548                         else
 549                         {
 550                                 fprintf(stderr, "-f requires a frame rate\n");
 551                                 exit(1);
 552                         }
 553                 }
 554                 else
 555                 if(!strcmp(argv[i], "-h"))
 556                 {
 557                         use_hires_quant = 1;
 558                 }
 559                 else
 560                 if(!strcmp(argv[i], "-m"))
 561                 {
 562                         i++;
 563                         if(i < argc)
 564                         {
 565                                 M = atol(argv[i]) + 1;
 566                         }
 567                         else
 568                         {
 569                                 fprintf(stderr, "-m requires a frame count\n");
 570                                 exit(1);
 571                         }
 572                 }
 573                 else
 574                 if(!strcmp(argv[i], "-n"))
 575                 {
 576                         i++;
 577                         if(i < argc)
 578                         {
 579                                 N = atol(argv[i]);
 580                         }
 581                         else
 582                         {
 583                                 fprintf(stderr, "-n requires a frame count\n");
 584                                 exit(1);
 585                         }
 586                 }
 587                 else
 588                 if(!strcmp(argv[i], "-p"))
 589                 {
 590                         prog_seq = 1;
 591                 }
 592                 else
 593                 if(!strcmp(argv[i], "-q"))
 594                 {
 595                         i++;
 596                         if(i < argc)
 597                         {
 598                                 fixed_mquant = atol(argv[i]);
 599                         }
 600                         else
 601                         {
 602                                 fprintf(stderr, "-q requires a quantization value\n");
 603                                 exit(1);
 604                         }
 605                 }
 606                 else
 607                 if(!strcmp(argv[i], "-u"))
 608                 {
 609                         processors = 1;
 610                 }
 611                 else
 612                 if(!strcmp(argv[i], "-422"))
 613                 {
 614                         chroma_format = 2;
 615                 }
 616                 else
 617                 if(!strcmp(argv[i], "-g"))
 618                 {
 619                         seq_header_every_gop = 1;
 620                 }
 621                 else
 622                 if(!strcmp(argv[i], "-"))
 623                 {
 624                         do_stdin = 1;
 625                 }
 626                 else
 627 /* Start or end frame if number */
 628                 if(isnum)
 629                 {
 630                         if(start_frame < 0)
 631                                 start_frame = atol(argv[i]);
 632                         else
 633                         if(end_frame < 0)
 634                                 end_frame = atol(argv[i]);
 635                 }
 636                 else
 637                 if(!strlen(tplorg) && !do_stdin && !do_buffers)
 638                 {
 639 /* Input path */
 640                         strncpy(tplorg, argv[i], STRINGLEN);
 641                 }
 642                 else
 643                 if(!strlen(out_path))
 644                 {
 645 /* Output path */
 646                         strncpy(out_path, argv[i], STRINGLEN);
 647                 }
 648         }
 649 //printf("readcmdline 4\n");
 650
 651         if(!strlen(out_path))
 652         {
 653 // Default output path
 654                 strncpy(out_path, tplorg, STRINGLEN);
 655                 for(i = strlen(out_path) - 1; i >= 0 && out_path[i] != '.'; i--)
 656                         ;
 657
 658                 if(i < 0) i = strlen(out_path);
 659
 660                 if(mpeg1)
 661                         sprintf(&out_path[i], ".m1v");
 662                 else
 663                         sprintf(&out_path[i], ".m2v");
 664         }
 665 //printf("readcmdline 5\n");
 666
 667 /* Get info from input file */
 668         if(do_stdin)
 669         {
 670                 inputtype = T_STDIN;
 671         }
 672         else
 673         if(do_buffers)
 674         {
 675                 inputtype = T_BUFFERS;
 676         }
 677         else
 678         if(mpeg3_check_sig(tplorg))
 679         {
 680                 mpeg_file = mpeg3_open(tplorg);
 681                 inputtype = T_MPEG;
 682         }
 683         else
 684         if(quicktime_check_sig(tplorg))
 685         {
 686                 qt_file = quicktime_open(tplorg, 1, 0);
 687                 inputtype = T_QUICKTIME;
 688         }
 689 //printf("readcmdline 6\n");
 690
 691         if(!qt_file && !mpeg_file && !do_stdin && !do_buffers)
 692         {
 693                 fprintf(stderr, "File format not recognized.\n");
 694                 exit(1);
 695         }
 696
 697 //printf("readcmdline 7\n");
 698         if(qt_file)
 699         {
 700                 if(!quicktime_video_tracks(qt_file))
 701                 {
 702                         fprintf(stderr, "No video tracks in file.\n");
 703                         exit(1);
 704                 }
 705
 706                 if(!quicktime_supported_video(qt_file, 0))
 707                 {
 708                         fprintf(stderr, "Unsupported video codec.\n");
 709                         exit(1);
 710                 }
 711         }
 712 //printf("readcmdline 8\n");
 713
 714 /************************************************************************
 715  *                            BEGIN PARAMETER FILE
 716  ************************************************************************/
 717
 718 /* To eliminate the user hassle we replaced the parameter file with hard coded constants. */
 719         strcpy(tplref,             "-");  /* name of intra quant matrix file     ("-": default matrix) */
 720         strcpy(iqname,             "-");  /* name of intra quant matrix file     ("-": default matrix) */
 721         strcpy(niqname,            "-");  /* name of non intra quant matrix file ("-": default matrix) */
 722         strcpy(statname,           "/dev/null");  /* name of statistics file ("-": stdout ) */
 723
 724         if(qt_file)
 725         {
 726                 nframes =                  quicktime_video_length(qt_file, 0);  /* number of frames */
 727                 horizontal_size =          quicktime_video_width(qt_file, 0);
 728                 vertical_size =            quicktime_video_height(qt_file, 0);
 729         }
 730         else
 731         if(mpeg_file)
 732         {
 733                 nframes =                  0x7fffffff;  /* Use percentage instead */
 734                 horizontal_size =          mpeg3_video_width(mpeg_file, 0);
 735                 vertical_size =            mpeg3_video_height(mpeg_file, 0);
 736         }
 737         else
 738         if(do_stdin)
 739         {
 740                 unsigned char data[1024];
 741                 nframes =                  0x7fffffff;
 742
 743                 fgets(data, 1024, stdin_fd);
 744                 horizontal_size =          atol(data);
 745                 fgets(data, 1024, stdin_fd);
 746                 vertical_size =            atol(data);
 747         }
 748         else
 749         if(do_buffers)
 750         {
 751                 nframes = 0x7fffffff;
 752         }
 753
 754
 755         h = m = s = f =            0;  /* timecode of first frame */
 756         fieldpic =                 0;  /* 0: progressive, 1: bottom first, 2: top first, 3 = progressive seq, field MC and DCT in picture */
 757         low_delay =                0;  /* low_delay  */
 758         constrparms =              0;  /* constrained_parameters_flag */
 759         profile =                  4;  /* Profile ID: Simple = 5, Main = 4, SNR = 3, Spatial = 2, High = 1 */
 760         level =                    4;  /* Level ID:   Low = 10, Main = 8, High 1440 = 6, High = 4                  */
 761         video_format =             2;  /* video_format: 0=comp., 1=PAL, 2=NTSC, 3=SECAM, 4=MAC, 5=unspec. */
 762         color_primaries =          5;  /* color_primaries */
 763         dctsatlim               = mpeg1 ? 255 : 2047;
 764         dctsatlim = 255;
 765         transfer_characteristics = 5;  /* transfer_characteristics */
 766         matrix_coefficients =      4;  /* matrix_coefficients (not used) */
 767         display_horizontal_size =  horizontal_size;
 768         display_vertical_size =    vertical_size;
 769         cur_picture.dc_prec =      0;  /* intra_dc_precision (0: 8 bit, 1: 9 bit, 2: 10 bit, 3: 11 bit */
 770         cur_picture.topfirst =     1;  /* top_field_first */
 771
 772         frame_pred_dct_tab[0] =    mpeg1 ? 1 : 0;  /* frame_pred_frame_dct (I P B) */
 773         frame_pred_dct_tab[1] =    mpeg1 ? 1 : 0;  /* frame_pred_frame_dct (I P B) */
 774         frame_pred_dct_tab[2] =    mpeg1 ? 1 : 0;  /* frame_pred_frame_dct (I P B) */
 775
 776         conceal_tab[0]                   = 0;  /* concealment_motion_vectors (I P B) */
 777         conceal_tab[1]                   = 0;  /* concealment_motion_vectors (I P B) */
 778         conceal_tab[2]                   = 0;  /* concealment_motion_vectors (I P B) */
 779         qscale_tab[0]                    = mpeg1 ? 0 : 1;  /* q_scale_type  (I P B) */
 780         qscale_tab[1]                    = mpeg1 ? 0 : 1;  /* q_scale_type  (I P B) */
 781         qscale_tab[2]                    = mpeg1 ? 0 : 1;  /* q_scale_type  (I P B) */
 782
 783         intravlc_tab[0]                  = 0;  /* intra_vlc_format (I P B)*/
 784         intravlc_tab[1]                  = 0;  /* intra_vlc_format (I P B)*/
 785         intravlc_tab[2]                  = 0;  /* intra_vlc_format (I P B)*/
 786         altscan_tab[0]                   = 0;  /* alternate_scan_hv (I P B) */
 787         altscan_tab[1]                   = 0;  /* alternate_scan_hv (I P B) */
 788         altscan_tab[2]                   = 0;  /* alternate_scan_hv (I P B) */
 789         opt_dc_prec         = 0;  /* 8 bits */
 790         opt_topfirst        = (fieldpic == 2);
 791         opt_repeatfirst     = 0;
 792         opt_prog_frame      = prog_seq;
 793         cur_picture.repeatfirst =              0;  /* repeat_first_field */
 794         cur_picture.prog_frame =               prog_seq;  /* progressive_frame */
 795 /* P:  forw_hor_f_code forw_vert_f_code search_width/height */
 796     motion_data = (struct motion_data *)malloc(3 * sizeof(struct motion_data));
 797         video_buffer_size =        46 * 1024 * 8;
 798
 799 /************************************************************************
 800  *                                END PARAMETER FILE
 801  ************************************************************************/
 802 //printf("readcmdline 10\n");
 803
 804         if(mpeg1)
 805         {
 806                 opt_prog_frame = 1;
 807                 cur_picture.prog_frame = 1;
 808                 prog_seq = 1;
 809         }
 810
 811         if(qt_file)
 812         {
 813                 input_frame_rate = quicktime_frame_rate(qt_file, 0);
 814         }
 815         else
 816         if(mpeg_file)
 817         {
 818                 input_frame_rate = mpeg3_frame_rate(mpeg_file, 0);
 819         }
 820         else
 821         if(do_stdin)
 822         {
 823                 char data[1024];
 824
 825                 fgets(data, 1024, stdin_fd);
 826
 827                 input_frame_rate = atof(data);
 828         }
 829
 830
 831         if(frame_rate < 0)
 832         {
 833                 frame_rate = input_frame_rate;
 834         }
 835 //printf("readcmdline 11\n");
 836
 837 //processors = 1;
 838 //nframes = 16;
 839         if(start_frame >= 0 && end_frame >= 0)
 840         {
 841                 nframes = end_frame - start_frame;
 842                 frame0 = start_frame;
 843         }
 844         else
 845         if(start_frame >= 0)
 846         {
 847                 end_frame = nframes;
 848                 nframes -= start_frame;
 849                 frame0 = start_frame;
 850         }
 851         else
 852         {
 853                 start_frame = 0;
 854                 end_frame = nframes;
 855         }
 856 //printf("readcmdline 12\n");
 857
 858 // Show status
 859         if(verbose)
 860         {
 861                 printf("Encoding: %s frames %ld\n", out_path, nframes);
 862
 863         if(fixed_mquant == 0)
 864                 printf("   bitrate %.0f\n", bit_rate);
 865         else
 866                 printf("   quantization %d\n", fixed_mquant);
 867         printf("   %d frames between I frames   %d frames between P frames\n", N, M - 1);
 868         printf("   %s\n", (prog_seq ? "progressive" : "interlaced"));
 869                 printf("   %s\n", (mpeg1 ? "MPEG-1" : "MPEG-2"));
 870                 printf("   %s\n", (chroma_format == 1) ? "YUV-420" : "YUV-422");
 871                 printf("   %d processors\n", processors);
 872                 printf("   %.02f frames per second\n", frame_rate);
 873                 printf("   Denoise %s\n", INTTOYES(use_denoise_quant));
 874                 printf("   Aspect ratio index %d\n", aspectratio);
 875                 printf("   Hires quantization %s\n", INTTOYES(use_hires_quant));
 876
 877
 878                 if(mpeg_file)
 879                 {
 880                         fprintf(stderr, "(MPEG to MPEG transcoding for official use only.)\n");
 881                 }
 882         }
 883
 884
 885
 886         {
 887                 int radius_x = ((param_searchrad + 4) / 8) * 8;
 888                 int radius_y = ((param_searchrad * vertical_size / horizontal_size + 4) / 8) * 8;
 889                 int c;
 890
 891                 /* TODO: These f-codes should really be adjusted for each
 892                    picture type... */
 893                 c=5;
 894                 if( radius_x*M < 64) c = 4;
 895                 if( radius_x*M < 32) c = 3;
 896                 if( radius_x*M < 16) c = 2;
 897                 if( radius_x*M < 8) c = 1;
 898
 899                 if (!motion_data)
 900                         error("malloc failed\n");
 901
 902                 for (i=0; i<M; i++)
 903                 {
 904                         if(i==0)
 905                         {
 906                                 motion_data[i].forw_hor_f_code  = c;
 907                                 motion_data[i].forw_vert_f_code = c;
 908                                 motion_data[i].sxf = MAX(1,radius_x*M);
 909                                 motion_data[i].syf = MAX(1,radius_y*M);
 910                         }
 911                         else
 912                         {
 913                                 motion_data[i].forw_hor_f_code  = c;
 914                                 motion_data[i].forw_vert_f_code = c;
 915                                 motion_data[i].sxf = MAX(1,radius_x*i);
 916                                 motion_data[i].syf = MAX(1,radius_y*i);
 917                                 motion_data[i].back_hor_f_code  = c;
 918                                 motion_data[i].back_vert_f_code = c;
 919                                 motion_data[i].sxb = MAX(1,radius_x*(M-i));
 920                                 motion_data[i].syb = MAX(1,radius_y*(M-i));
 921                         }
 922                 }
 923
 924         }
 925
 926 //    vbv_buffer_size = floor(((double)bit_rate * 0.20343) / 16384.0);
 927     if(mpeg1)
 928                 vbv_buffer_size = 20 * 16384;
 929         else
 930                 vbv_buffer_size = 112 * 16384;
 931
 932         fast_mc_frac    = 10;
 933         mc_44_red               = 2;
 934         mc_22_red               = 3;
 935
 936     if(vbv_buffer_size > vbvlim[(level - 4) >> 1])
 937         vbv_buffer_size = vbvlim[(level - 4) >> 1];
 938
 939 /* Set up frame buffers */
 940         frame_buffer = malloc(horizontal_size * vertical_size * 3 + 4);
 941         row_pointers = malloc(sizeof(unsigned char*) * vertical_size);
 942         for(i = 0; i < vertical_size; i++) row_pointers[i] = &frame_buffer[horizontal_size * 3 * i];
 943
 944 // Get frame rate code from input frame rate
 945         for(i = 0; i < total_frame_rates; i++)
 946         {
 947                 if(fabs(frame_rate - ratetab[i]) < 0.001) frame_rate_code = i + 1;
 948         }
 949
 950 /* make flags boolean (x!=0 -> x=1) */
 951   mpeg1 = !!mpeg1;
 952   fieldpic = !!fieldpic;
 953   low_delay = !!low_delay;
 954   constrparms = !!constrparms;
 955   prog_seq = !!prog_seq;
 956   cur_picture.topfirst = !!cur_picture.topfirst;
 957
 958   for (i = 0; i < 3; i++)
 959   {
 960     frame_pred_dct_tab[i] = !!frame_pred_dct_tab[i];
 961     conceal_tab[i] = !!conceal_tab[i];
 962     qscale_tab[i] = !!qscale_tab[i];
 963     intravlc_tab[i] = !!intravlc_tab[i];
 964     altscan_tab[i] = !!altscan_tab[i];
 965   }
 966   cur_picture.repeatfirst = !!cur_picture.repeatfirst;
 967   cur_picture.prog_frame = !!cur_picture.prog_frame;
 968
 969   /* make sure MPEG specific parameters are valid */
 970   range_checks();
 971
 972   /* timecode -> frame number */
 973   tc0 = h;
 974   tc0 = 60*tc0 + m;
 975   tc0 = 60*tc0 + s;
 976   tc0 = (int)(frame_rate+0.5)*tc0 + f;
 977
 978   qt_output = 0;
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989   if (!mpeg1)
 990   {
 991     profile_and_level_checks();
 992   }
 993   else
 994   {
 995     /* MPEG-1 */
 996     if (constrparms)
 997     {
 998       if (horizontal_size>768
 999           || vertical_size>576
1000           || ((horizontal_size+15)/16)*((vertical_size+15) / 16) > 396
1001           || ((horizontal_size+15)/16)*((vertical_size+15) / 16)*frame_rate>396*25.0
1002           || frame_rate>30.0)
1003       {
1004         if (!quiet)
1005           fprintf(stderr,"*** Warning: setting constrained_parameters_flag = 0\n");
1006         constrparms = 0;
1007       }
1008     }
1009   }
1010
1011   /* relational checks */
1012
1013   if (mpeg1)
1014   {
1015     if (!prog_seq)
1016     {
1017       prog_seq = 1;
1018     }
1019
1020     if (chroma_format!=CHROMA420)
1021     {
1022       chroma_format = CHROMA420;
1023     }
1024
1025     if (cur_picture.dc_prec!=0)
1026     {
1027       cur_picture.dc_prec = 0;
1028     }
1029
1030     for (i=0; i<3; i++)
1031       if (qscale_tab[i])
1032       {
1033         qscale_tab[i] = 0;
1034       }
1035
1036     for (i=0; i<3; i++)
1037       if (intravlc_tab[i])
1038       {
1039         intravlc_tab[i] = 0;
1040       }
1041
1042     for (i=0; i<3; i++)
1043       if (altscan_tab[i])
1044       {
1045         altscan_tab[i] = 0;
1046       }
1047   }
1048
1049   if (!mpeg1 && constrparms)
1050   {
1051     constrparms = 0;
1052   }
1053
1054   if (prog_seq && !cur_picture.prog_frame)
1055   {
1056     cur_picture.prog_frame = 1;
1057   }
1058
1059   if (cur_picture.prog_frame && fieldpic)
1060   {
1061     fieldpic = 0;
1062   }
1063
1064   if (!cur_picture.prog_frame && cur_picture.repeatfirst)
1065   {
1066     cur_picture.repeatfirst = 0;
1067   }
1068
1069   if (cur_picture.prog_frame)
1070   {
1071     for (i=0; i<3; i++)
1072       if (!frame_pred_dct_tab[i])
1073       {
1074         frame_pred_dct_tab[i] = 1;
1075       }
1076   }
1077
1078   if (prog_seq && !cur_picture.repeatfirst && cur_picture.topfirst)
1079   {
1080      if (!quiet)
1081        fprintf(stderr,"Warning: setting top_field_first = 0\n");
1082     cur_picture.topfirst = 0;
1083   }
1084
1085   /* search windows */
1086   for (i=0; i<M; i++)
1087   {
1088     if (motion_data[i].sxf > (4<<motion_data[i].forw_hor_f_code)-1)
1089     {
1090       if (!quiet)
1091         fprintf(stderr,
1092           "Warning: reducing forward horizontal search width to %d\n",
1093           (4<<motion_data[i].forw_hor_f_code)-1);
1094       motion_data[i].sxf = (4<<motion_data[i].forw_hor_f_code)-1;
1095     }
1096
1097     if (motion_data[i].syf > (4<<motion_data[i].forw_vert_f_code)-1)
1098     {
1099       if (!quiet)
1100         fprintf(stderr,
1101           "Warning: reducing forward vertical search width to %d\n",
1102           (4<<motion_data[i].forw_vert_f_code)-1);
1103       motion_data[i].syf = (4<<motion_data[i].forw_vert_f_code)-1;
1104     }
1105
1106     if (i!=0)
1107     {
1108       if (motion_data[i].sxb > (4<<motion_data[i].back_hor_f_code)-1)
1109       {
1110         if (!quiet)
1111           fprintf(stderr,
1112             "Warning: reducing backward horizontal search width to %d\n",
1113             (4<<motion_data[i].back_hor_f_code)-1);
1114         motion_data[i].sxb = (4<<motion_data[i].back_hor_f_code)-1;
1115       }
1116
1117       if (motion_data[i].syb > (4<<motion_data[i].back_vert_f_code)-1)
1118       {
1119         if (!quiet)
1120           fprintf(stderr,
1121             "Warning: reducing backward vertical search width to %d\n",
1122             (4<<motion_data[i].back_vert_f_code)-1);
1123         motion_data[i].syb = (4<<motion_data[i].back_vert_f_code)-1;
1124       }
1125     }
1126   }
1127
1128 }
1129
1130 /*
1131   If the user has selected suppression of hf noise via
1132   quantisation then we boost quantisation of hf components
1133   EXPERIMENTAL: currently a linear ramp from 0 at 4pel to
1134   50% increased quantisation...
1135 */
1136
1137 static int quant_hfnoise_filt(int orgquant, int qmat_pos )
1138 {
1139         int x = qmat_pos % 8;
1140         int y = qmat_pos / 8;
1141         int qboost = 1024;
1142
1143         if(!use_denoise_quant)
1144         {
1145                 return orgquant;
1146         }
1147
1148         /* Maximum 50% quantisation boost for HF components... */
1149         if( x > 4 )
1150                 qboost += (256*(x-4)/3);
1151         if( y > 4 )
1152                 qboost += (256*(y-4)/3);
1153
1154         return (orgquant * qboost + 512)/ 1024;
1155 }
1156
1157 static void readquantmat()
1158 {
1159   int i,v,q;
1160         load_iquant = 0;
1161         load_niquant = 0;
1162
1163   if (iqname[0]=='-')
1164   {
1165         if(use_hires_quant)
1166         {
1167                 load_iquant |= 1;
1168                 for (i=0; i<64; i++)
1169                 {
1170                         intra_q[i] = hires_intra_quantizer_matrix_hv[i];
1171                 }
1172         }
1173         else
1174         {
1175                 load_iquant = use_denoise_quant;
1176                 for (i=0; i<64; i++)
1177                 {
1178                         v = quant_hfnoise_filt(default_intra_quantizer_matrix_hv[i], i);
1179                         if (v<1 || v>255)
1180                                 error("value in intra quant matrix invalid (after noise filt adjust)");
1181                         intra_q[i] = v;
1182                 }
1183         }
1184   }
1185
1186 /* TODO: Inv Quant matrix initialisation should check if the fraction fits in 16 bits! */
1187   if (niqname[0]=='-')
1188   {
1189                 if(use_hires_quant)
1190                 {
1191                         for (i=0; i<64; i++)
1192                         {
1193                                 inter_q[i] = hires_nonintra_quantizer_matrix_hv[i];
1194                         }
1195                 }
1196                 else
1197                 {
1198 /* default non-intra matrix is all 16's. For *our* default we use something
1199    more suitable for domestic analog sources... which is non-standard...*/
1200                         load_niquant |= 1;
1201                         for (i=0; i<64; i++)
1202                         {
1203                                 v = quant_hfnoise_filt(default_nonintra_quantizer_matrix_hv[i],i);
1204                                 if (v<1 || v>255)
1205                                         error("value in non-intra quant matrix invalid (after noise filt adjust)");
1206                                 inter_q[i] = v;
1207                         }
1208                 }
1209   }
1210
1211         for (i=0; i<64; i++)
1212         {
1213                 i_intra_q[i] = (int)(((double)IQUANT_SCALE) / ((double)intra_q[i]));
1214                 i_inter_q[i] = (int)(((double)IQUANT_SCALE) / ((double)inter_q[i]));
1215         }
1216
1217         for( q = 1; q <= 112; ++q )
1218         {
1219                 for (i=0; i<64; i++)
1220                 {
1221                         intra_q_tbl[q][i] = intra_q[i] * q;
1222                         inter_q_tbl[q][i] = inter_q[i] * q;
1223                         intra_q_tblf[q][i] = (float)intra_q_tbl[q][i];
1224                         inter_q_tblf[q][i] = (float)inter_q_tbl[q][i];
1225                         i_intra_q_tblf[q][i] = 1.0f/ ( intra_q_tblf[q][i] * 0.98);
1226                         i_intra_q_tbl[q][i] = (IQUANT_SCALE/intra_q_tbl[q][i]);
1227                         i_inter_q_tblf[q][i] =  1.0f/ (inter_q_tblf[q][i] * 0.98);
1228                         i_inter_q_tbl[q][i] = (IQUANT_SCALE/inter_q_tbl[q][i] );
1229                 }
1230         }
1231 }