1 /* mpeg2enc.c, main() and parameter file reading */
3 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
6 * Disclaimer of Warranty
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.
16 * This disclaimer of warranty extends to the user of these programs and user's
17 * customers, employees, agents, transferees, successors, and assigns.
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
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
30 #define MAX(a,b) ( (a)>(b) ? (a) : (b) )
37 #define GLOBAL_ /* used by global.h */
41 /* private prototypes */
42 static void init _ANSI_ARGS_((void));
43 static void readcmdline _ANSI_ARGS_((int argc, char *argv[]));
44 static void readquantmat _ANSI_ARGS_((void));
47 // Hack for libdv to remove glib dependancy
50 g_log (const char *log_domain,
58 g_logv (const char *log_domain,
66 void mpeg2enc_set_w(int width)
68 horizontal_size = width;
71 void mpeg2enc_set_h(int height)
73 vertical_size = height;
76 void mpeg2enc_set_rate(double rate)
78 input_frame_rate = rate;
81 void mpeg2enc_set_input_buffers(int eof, char *y, char *u, char *v)
83 pthread_mutex_lock(&output_lock);
84 input_buffer_end = eof;
88 pthread_mutex_unlock(&input_lock);
89 // Wait for buffers to get copied before returning.
90 pthread_mutex_lock(©_lock);
93 void mpeg2enc_init_buffers()
95 pthread_mutex_init(&input_lock, 0);
96 pthread_mutex_init(&output_lock, 0);
97 pthread_mutex_init(©_lock, 0);
98 pthread_mutex_lock(&input_lock);
99 pthread_mutex_lock(©_lock);
100 input_buffer_end = 0;
103 int mpeg2enc(int argc, char *argv[])
110 /* Read command line */
111 readcmdline(argc, argv);
113 /* read quantization matrices */
116 if(!strlen(out_path))
118 fprintf(stderr, "No output file given.\n");
121 /* open output file */
122 if(!(outfile = fopen(out_path, "wb")))
124 sprintf(errortext,"Couldn't create output file %s", out_path);
130 if(nframes < 0x7fffffff)
131 printf("Frame Completion Current bitrate Predicted file size\n");
134 stop_slice_engines();
135 stop_motion_engines();
136 stop_transform_engines();
137 stop_itransform_engines();
142 if(mpeg_file) mpeg3_close(mpeg_file);
148 pthread_mutex_destroy(&input_lock);
149 pthread_mutex_destroy(&output_lock);
153 int HorzMotionCode(int i)
161 if ((i < 64) || (constrparms))
167 if ((i < 512) || (level == 10))
169 if ((i < 1024) || (level == 8))
176 int VertMotionCode(int i)
184 if ((i < 64) || (level == 10) || (constrparms))
190 Wrapper for malloc that allocates pbuffers aligned to the
191 specified byte boundary and checks for failure.
192 N.b. don't try to free the resulting pointers, eh...
193 BUG: Of course this won't work if a char * won't fit in an int....
195 static uint8_t *bufalloc( size_t size )
197 char *buf = malloc( size + BUFFER_ALIGN );
202 error("malloc failed\n");
204 adjust = ((unsigned long)buf) & (BUFFER_ALIGN-1);
205 if( adjust ) adjust = BUFFER_ALIGN - adjust;
206 memset(buf += adjust, 0, size);
207 return (uint8_t*)buf;
213 static int block_count_tab[3] = {6,8,12};
214 int lum_buffer_size, chrom_buffer_size;
215 pthread_mutexattr_t mutex_attr;
216 pthread_mutexattr_init(&mutex_attr);
217 pthread_mutex_init(&test_lock, &mutex_attr);
219 bzero(&cur_picture, sizeof(pict_data_s));
228 /* round picture dimensions to nZearest multiple of 16 or 32 */
229 mb_width = (horizontal_size+15)/16;
230 mb_height = prog_seq ?
231 (vertical_size + 15) / 16 :
232 2 * ((vertical_size + 31) / 32);
233 mb_height2 = fieldpic ?
235 mb_height; /* for field pictures */
236 width = 16 * mb_width;
237 height = 16 * mb_height;
239 chrom_width = (chroma_format==CHROMA444) ? width : width>>1;
240 chrom_height = (chroma_format!=CHROMA420) ? height : height>>1;
242 height2 = fieldpic ? height>>1 : height;
243 width2 = fieldpic ? width<<1 : width;
244 chrom_width2 = fieldpic ? chrom_width<<1 : chrom_width;
246 block_count = block_count_tab[chroma_format-1];
247 lum_buffer_size = (width*height) +
248 sizeof(uint8_t) *(width/2)*(height/2) +
249 sizeof(uint8_t) *(width/4)*(height/4+1);
250 chrom_buffer_size = chrom_width*chrom_height;
252 fsubsample_offset = (width)*(height) * sizeof(uint8_t);
253 qsubsample_offset = fsubsample_offset + (width/2)*(height/2)*sizeof(uint8_t);
258 mb_per_pict = mb_width*mb_height2;
261 if (!(clp = (unsigned char *)malloc(1024)))
262 error("malloc failed\n");
264 for (i=-384; i<640; i++)
265 clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
269 /* Allocate the frame buffer */
272 frame_buffers = (uint8_t ***)
273 bufalloc(2*READ_LOOK_AHEAD*sizeof(uint8_t**));
275 for(n=0;n<2*READ_LOOK_AHEAD;n++)
277 frame_buffers[n] = (uint8_t **) bufalloc(3*sizeof(uint8_t*));
280 frame_buffers[n][i] =
281 bufalloc( (i==0) ? lum_buffer_size : chrom_buffer_size );
287 /* TODO: The ref and aux frame buffers are no redundant! */
288 for( i = 0 ; i<3; i++)
290 int size = (i==0) ? lum_buffer_size : chrom_buffer_size;
291 newrefframe[i] = bufalloc(size);
292 oldrefframe[i] = bufalloc(size);
293 auxframe[i] = bufalloc(size);
294 predframe[i] = bufalloc(size);
297 cur_picture.qblocks =
298 (int16_t (*)[64])bufalloc(mb_per_pict*block_count*sizeof(int16_t [64]));
300 /* Initialise current transformed picture data tables
301 These will soon become a buffer for transformed picture data to allow
302 look-ahead for bit allocation etc.
304 cur_picture.mbinfo = (
305 struct mbinfo *)bufalloc(mb_per_pict*sizeof(struct mbinfo));
308 (int16_t (*)[64])bufalloc(mb_per_pict * block_count * sizeof(int16_t [64]));
311 /* open statistics output file */
312 if(statname[0]=='-') statfile = stdout;
314 if(!(statfile = fopen(statname,"w")))
316 sprintf(errortext,"Couldn't create statistics output file %s",statname);
320 ratectl = malloc(processors * sizeof(ratectl_t*));
321 for(i = 0; i < processors; i++)
322 ratectl[i] = calloc(1, sizeof(ratectl_t));
326 /* Start parallel threads */
328 //printf("init 1\n");
329 start_motion_engines();
330 //printf("init 2\n");
331 start_transform_engines();
332 //printf("init 3\n");
333 start_itransform_engines();
334 //printf("init 4\n");
335 start_slice_engines();
336 //printf("init 5\n");
342 fprintf(stderr,"%s\n",text);
346 #define STRINGLEN 254
350 /* Get processor count */
353 if(proc = fopen("/proc/cpuinfo", "r"))
358 fgets(string, 1024, proc);
359 if(!strncasecmp(string, "processor", 9))
361 char *ptr = strchr(string, ':');
365 result = atol(ptr) + 1;
369 if(!strncasecmp(string, "cpus detected", 13))
371 char *ptr = strchr(string, ':');
384 static void readcmdline(int argc, char *argv[])
388 // Master frame rate table must match decoder
389 static double ratetab[]=
390 {24000.0/1001.0, // Official rates
399 1, // Unofficial economy rates
406 // VBV buffer size limits
407 int vbvlim[4] = { 597, 448, 112, 29 };
408 long total_frame_rates = (sizeof(ratetab) / sizeof(double));
410 int param_searchrad = 16;
413 //printf("readcmdline 1\n");
414 frame0 = 0; /* number of first frame */
415 start_frame = end_frame = -1;
417 use_denoise_quant = 0;
419 bit_rate = 5000000; /* default bit_rate (bits/s) */
420 prog_seq = 0; /* progressive_sequence is faster */
421 mpeg1 = 0; /* ISO/IEC 11172-2 stream */
422 fixed_mquant = 0; /* vary the quantization */
425 N = 15; /* N (# of frames in GOP) */
426 M = 1; /* M (I/P frame distance) */
427 processors = calculate_smp();
429 chroma_format = 1; /* chroma_format: 1=4:2:0, 2=4:2:2, 3=4:4:4 LibMPEG3 only does 1 */
433 seq_header_every_gop = 0;
434 /* aspect_ratio_information 1=square pel, 2=4:3, 3=16:9, 4=2.11:1 */
441 //printf("readcmdline 2\n");
444 sprintf(tplorg, "%s", "");
445 sprintf(out_path, "%s", "");
447 #define INTTOYES(x) ((x) ? "Yes" : "No")
448 // This isn't used anymore as this is a library entry point.
451 printf("mpeg2encode V1.3, 2000/01/10\n"
452 "(C) 1996, MPEG Software Simulation Group\n"
453 "(C) 2001 Heroine Virtual\n"
454 "Usage: %s [options] <input file> <output file>\n\n"
455 " -1 generate an MPEG-1 stream instead of MPEG-2 (%s)\n"
456 " -422 generate YUV 4:2:2 output\n"
457 " -b bitrate fix the bitrate, vary the quantization (%d)\n"
459 " -f rate Convert framerate\n"
460 " -h High resolution quantization table (%s)\n"
461 " -m frames set number of frames between P frames (%d)\n"
462 " -n frames set number of frames between I frames (%d)\n"
463 " -p encode progressive frames (%s)\n"
464 " -q quantization fix the quantization, vary the bitrate\n"
465 " [number] Start encoding from frame number to end\n"
466 " [number1] [number2] Encode frame number 1 to frame number 2\n"
467 " -u Use only 1 processor\n\n"
468 "Default settings:\n"
469 " fixed 5000000 bits/sec\n"
472 " 15 frames between I frames 0 frames between P frames\n\n"
473 "For the recommended encoding parameters see docs/index.html.\n",
475 mpeg1 ? "MPEG-1" : "MPEG-2",
477 INTTOYES(use_denoise_quant),
478 INTTOYES(use_hires_quant),
484 //printf("readcmdline 3\n");
486 for(i = 1; i < argc; i++)
490 for(j = 0; j < strlen(argv[i]) && isnum; j++)
492 if(isalpha(argv[i][j])) isnum = 0;
496 //printf("readcmdline %s\n", argv[i]);
497 if(!strcmp(argv[i], "-1"))
502 if(!strcmp(argv[i], "-a"))
507 aspectratio = atoi(argv[i]);
511 fprintf(stderr, "-i needs an aspect ratio enumeration.\n");
516 if(!strcmp(argv[i], "-b"))
521 bit_rate = atol(argv[i]);
525 fprintf(stderr, "-b requires a bitrate\n");
530 if(!strcmp(argv[i], "-d"))
532 use_denoise_quant = 1;
535 if(!strcmp(argv[i], "-f"))
540 frame_rate = atof(argv[i]);
544 fprintf(stderr, "-f requires a frame rate\n");
549 if(!strcmp(argv[i], "-h"))
554 if(!strcmp(argv[i], "-m"))
559 M = atol(argv[i]) + 1;
563 fprintf(stderr, "-m requires a frame count\n");
568 if(!strcmp(argv[i], "-n"))
577 fprintf(stderr, "-n requires a frame count\n");
582 if(!strcmp(argv[i], "-p"))
587 if(!strcmp(argv[i], "-q"))
592 fixed_mquant = atol(argv[i]);
596 fprintf(stderr, "-q requires a quantization value\n");
601 if(!strcmp(argv[i], "-u"))
606 if(!strcmp(argv[i], "-422"))
611 if(!strcmp(argv[i], "-g"))
613 seq_header_every_gop = 1;
616 if(!strcmp(argv[i], "-"))
621 /* Start or end frame if number */
625 start_frame = atol(argv[i]);
628 end_frame = atol(argv[i]);
631 if(!strlen(tplorg) && !do_stdin && !do_buffers)
634 strncpy(tplorg, argv[i], STRINGLEN);
637 if(!strlen(out_path))
640 strncpy(out_path, argv[i], STRINGLEN);
643 //printf("readcmdline 4\n");
645 if(!strlen(out_path))
647 // Default output path
648 strncpy(out_path, tplorg, STRINGLEN);
649 for(i = strlen(out_path) - 1; i >= 0 && out_path[i] != '.'; i--)
652 if(i < 0) i = strlen(out_path);
655 sprintf(&out_path[i], ".m1v");
657 sprintf(&out_path[i], ".m2v");
659 //printf("readcmdline 5\n");
661 /* Get info from input file */
669 inputtype = T_BUFFERS;
672 if(mpeg3_check_sig(tplorg))
675 mpeg_file = mpeg3_open(tplorg, &error_return);
678 //printf("readcmdline 6\n");
680 if(!mpeg_file && !do_stdin && !do_buffers)
682 fprintf(stderr, "File format not recognized.\n");
686 //printf("readcmdline 8\n");
688 /************************************************************************
689 * BEGIN PARAMETER FILE
690 ************************************************************************/
692 /* To eliminate the user hassle we replaced the parameter file with hard coded constants. */
693 strcpy(tplref, "-"); /* name of intra quant matrix file ("-": default matrix) */
694 strcpy(iqname, "-"); /* name of intra quant matrix file ("-": default matrix) */
695 strcpy(niqname, "-"); /* name of non intra quant matrix file ("-": default matrix) */
696 strcpy(statname, "/dev/null"); /* name of statistics file ("-": stdout ) */
700 nframes = 0x7fffffff; /* Use percentage instead */
701 horizontal_size = mpeg3_video_width(mpeg_file, 0);
702 vertical_size = mpeg3_video_height(mpeg_file, 0);
708 nframes = 0x7fffffff;
710 fgets(data, 1024, stdin_fd);
711 horizontal_size = atol(data);
712 fgets(data, 1024, stdin_fd);
713 vertical_size = atol(data);
718 nframes = 0x7fffffff;
722 h = m = s = f = 0; /* timecode of first frame */
723 fieldpic = 0; /* 0: progressive, 1: bottom first, 2: top first, 3 = progressive seq, field MC and DCT in picture */
724 low_delay = 0; /* low_delay */
725 constrparms = 0; /* constrained_parameters_flag */
726 profile = 4; /* Profile ID: Simple = 5, Main = 4, SNR = 3, Spatial = 2, High = 1 */
727 level = 4; /* Level ID: Low = 10, Main = 8, High 1440 = 6, High = 4 */
728 video_format = 2; /* video_format: 0=comp., 1=PAL, 2=NTSC, 3=SECAM, 4=MAC, 5=unspec. */
729 color_primaries = 5; /* color_primaries */
730 dctsatlim = mpeg1 ? 255 : 2047;
732 transfer_characteristics = 5; /* transfer_characteristics */
733 matrix_coefficients = 4; /* matrix_coefficients (not used) */
734 display_horizontal_size = horizontal_size;
735 display_vertical_size = vertical_size;
736 cur_picture.dc_prec = 0; /* intra_dc_precision (0: 8 bit, 1: 9 bit, 2: 10 bit, 3: 11 bit */
737 cur_picture.topfirst = 1; /* top_field_first */
739 frame_pred_dct_tab[0] = mpeg1 ? 1 : 0; /* frame_pred_frame_dct (I P B) */
740 frame_pred_dct_tab[1] = mpeg1 ? 1 : 0; /* frame_pred_frame_dct (I P B) */
741 frame_pred_dct_tab[2] = mpeg1 ? 1 : 0; /* frame_pred_frame_dct (I P B) */
743 conceal_tab[0] = 0; /* concealment_motion_vectors (I P B) */
744 conceal_tab[1] = 0; /* concealment_motion_vectors (I P B) */
745 conceal_tab[2] = 0; /* concealment_motion_vectors (I P B) */
746 qscale_tab[0] = mpeg1 ? 0 : 1; /* q_scale_type (I P B) */
747 qscale_tab[1] = mpeg1 ? 0 : 1; /* q_scale_type (I P B) */
748 qscale_tab[2] = mpeg1 ? 0 : 1; /* q_scale_type (I P B) */
750 intravlc_tab[0] = 0; /* intra_vlc_format (I P B)*/
751 intravlc_tab[1] = 0; /* intra_vlc_format (I P B)*/
752 intravlc_tab[2] = 0; /* intra_vlc_format (I P B)*/
753 altscan_tab[0] = 0; /* alternate_scan_hv (I P B) */
754 altscan_tab[1] = 0; /* alternate_scan_hv (I P B) */
755 altscan_tab[2] = 0; /* alternate_scan_hv (I P B) */
756 opt_dc_prec = 0; /* 8 bits */
757 opt_topfirst = (fieldpic == 2);
759 opt_prog_frame = prog_seq;
760 cur_picture.repeatfirst = 0; /* repeat_first_field */
761 cur_picture.prog_frame = prog_seq; /* progressive_frame */
762 /* P: forw_hor_f_code forw_vert_f_code search_width/height */
763 motion_data = (struct motion_data *)malloc(3 * sizeof(struct motion_data));
764 video_buffer_size = 46 * 1024 * 8;
766 /************************************************************************
768 ************************************************************************/
769 //printf("readcmdline 10\n");
774 cur_picture.prog_frame = 1;
780 input_frame_rate = mpeg3_frame_rate(mpeg_file, 0);
787 fgets(data, 1024, stdin_fd);
789 input_frame_rate = atof(data);
795 frame_rate = input_frame_rate;
797 //printf("readcmdline 11\n");
801 if(start_frame >= 0 && end_frame >= 0)
803 nframes = end_frame - start_frame;
804 frame0 = start_frame;
810 nframes -= start_frame;
811 frame0 = start_frame;
818 //printf("readcmdline 12\n");
823 printf("Encoding: %s frames %d\n", out_path, nframes);
825 if(fixed_mquant == 0)
826 printf(" bitrate %.0f\n", bit_rate);
828 printf(" quantization %d\n", fixed_mquant);
829 printf(" %d frames between I frames %d frames between P frames\n", N, M - 1);
830 printf(" %s\n", (prog_seq ? "progressive" : "interlaced"));
831 printf(" %s\n", (mpeg1 ? "MPEG-1" : "MPEG-2"));
832 printf(" %s\n", (chroma_format == 1) ? "YUV-420" : "YUV-422");
833 printf(" %d processors\n", processors);
834 printf(" %.02f frames per second\n", frame_rate);
835 printf(" Denoise %s\n", INTTOYES(use_denoise_quant));
836 printf(" Aspect ratio index %d\n", aspectratio);
837 printf(" Hires quantization %s\n", INTTOYES(use_hires_quant));
842 fprintf(stderr, "(MPEG to MPEG transcoding for official use only.)\n");
849 int radius_x = ((param_searchrad + 4) / 8) * 8;
850 int radius_y = ((param_searchrad * vertical_size / horizontal_size + 4) / 8) * 8;
853 /* TODO: These f-codes should really be adjusted for each
856 if( radius_x*M < 64) c = 4;
857 if( radius_x*M < 32) c = 3;
858 if( radius_x*M < 16) c = 2;
859 if( radius_x*M < 8) c = 1;
862 error("malloc failed\n");
868 motion_data[i].forw_hor_f_code = c;
869 motion_data[i].forw_vert_f_code = c;
870 motion_data[i].sxf = MAX(1,radius_x*M);
871 motion_data[i].syf = MAX(1,radius_y*M);
875 motion_data[i].forw_hor_f_code = c;
876 motion_data[i].forw_vert_f_code = c;
877 motion_data[i].sxf = MAX(1,radius_x*i);
878 motion_data[i].syf = MAX(1,radius_y*i);
879 motion_data[i].back_hor_f_code = c;
880 motion_data[i].back_vert_f_code = c;
881 motion_data[i].sxb = MAX(1,radius_x*(M-i));
882 motion_data[i].syb = MAX(1,radius_y*(M-i));
888 // vbv_buffer_size = floor(((double)bit_rate * 0.20343) / 16384.0);
890 vbv_buffer_size = 20 * 16384;
892 vbv_buffer_size = 112 * 16384;
898 if(vbv_buffer_size > vbvlim[(level - 4) >> 1])
899 vbv_buffer_size = vbvlim[(level - 4) >> 1];
901 /* Set up frame buffers */
902 frame_buffer = malloc(horizontal_size * vertical_size * 3 + 4);
903 row_pointers = malloc(sizeof(unsigned char*) * vertical_size);
904 for(i = 0; i < vertical_size; i++) row_pointers[i] = &frame_buffer[horizontal_size * 3 * i];
906 // Get frame rate code from input frame rate
907 for(i = 0; i < total_frame_rates; i++)
909 if(fabs(frame_rate - ratetab[i]) < 0.001) frame_rate_code = i + 1;
912 /* make flags boolean (x!=0 -> x=1) */
914 fieldpic = !!fieldpic;
915 low_delay = !!low_delay;
916 constrparms = !!constrparms;
917 prog_seq = !!prog_seq;
918 cur_picture.topfirst = !!cur_picture.topfirst;
920 for (i = 0; i < 3; i++)
922 frame_pred_dct_tab[i] = !!frame_pred_dct_tab[i];
923 conceal_tab[i] = !!conceal_tab[i];
924 qscale_tab[i] = !!qscale_tab[i];
925 intravlc_tab[i] = !!intravlc_tab[i];
926 altscan_tab[i] = !!altscan_tab[i];
928 cur_picture.repeatfirst = !!cur_picture.repeatfirst;
929 cur_picture.prog_frame = !!cur_picture.prog_frame;
931 /* make sure MPEG specific parameters are valid */
934 /* timecode -> frame number */
938 tc0 = (int)(frame_rate+0.5)*tc0 + f;
942 profile_and_level_checks();
949 if (horizontal_size>768
951 || ((horizontal_size+15)/16)*((vertical_size+15) / 16) > 396
952 || ((horizontal_size+15)/16)*((vertical_size+15) / 16)*frame_rate>396*25.0
956 fprintf(stderr,"*** Warning: setting constrained_parameters_flag = 0\n");
962 /* relational checks */
971 if (chroma_format!=CHROMA420)
973 chroma_format = CHROMA420;
976 if (cur_picture.dc_prec!=0)
978 cur_picture.dc_prec = 0;
1000 if (!mpeg1 && constrparms)
1005 if (prog_seq && !cur_picture.prog_frame)
1007 cur_picture.prog_frame = 1;
1010 if (cur_picture.prog_frame && fieldpic)
1015 if (!cur_picture.prog_frame && cur_picture.repeatfirst)
1017 cur_picture.repeatfirst = 0;
1020 if (cur_picture.prog_frame)
1023 if (!frame_pred_dct_tab[i])
1025 frame_pred_dct_tab[i] = 1;
1029 if (prog_seq && !cur_picture.repeatfirst && cur_picture.topfirst)
1032 fprintf(stderr,"Warning: setting top_field_first = 0\n");
1033 cur_picture.topfirst = 0;
1036 /* search windows */
1039 if (motion_data[i].sxf > (4<<motion_data[i].forw_hor_f_code)-1)
1043 "Warning: reducing forward horizontal search width to %d\n",
1044 (4<<motion_data[i].forw_hor_f_code)-1);
1045 motion_data[i].sxf = (4<<motion_data[i].forw_hor_f_code)-1;
1048 if (motion_data[i].syf > (4<<motion_data[i].forw_vert_f_code)-1)
1052 "Warning: reducing forward vertical search width to %d\n",
1053 (4<<motion_data[i].forw_vert_f_code)-1);
1054 motion_data[i].syf = (4<<motion_data[i].forw_vert_f_code)-1;
1059 if (motion_data[i].sxb > (4<<motion_data[i].back_hor_f_code)-1)
1063 "Warning: reducing backward horizontal search width to %d\n",
1064 (4<<motion_data[i].back_hor_f_code)-1);
1065 motion_data[i].sxb = (4<<motion_data[i].back_hor_f_code)-1;
1068 if (motion_data[i].syb > (4<<motion_data[i].back_vert_f_code)-1)
1072 "Warning: reducing backward vertical search width to %d\n",
1073 (4<<motion_data[i].back_vert_f_code)-1);
1074 motion_data[i].syb = (4<<motion_data[i].back_vert_f_code)-1;
1082 If the user has selected suppression of hf noise via
1083 quantisation then we boost quantisation of hf components
1084 EXPERIMENTAL: currently a linear ramp from 0 at 4pel to
1085 50% increased quantisation...
1088 static int quant_hfnoise_filt(int orgquant, int qmat_pos )
1090 int x = qmat_pos % 8;
1091 int y = qmat_pos / 8;
1094 if(!use_denoise_quant)
1099 /* Maximum 50% quantisation boost for HF components... */
1101 qboost += (256*(x-4)/3);
1103 qboost += (256*(y-4)/3);
1105 return (orgquant * qboost + 512)/ 1024;
1108 static void readquantmat()
1119 for (i=0; i<64; i++)
1121 intra_q[i] = hires_intra_quantizer_matrix_hv[i];
1126 load_iquant = use_denoise_quant;
1127 for (i=0; i<64; i++)
1129 v = quant_hfnoise_filt(default_intra_quantizer_matrix_hv[i], i);
1131 error("value in intra quant matrix invalid (after noise filt adjust)");
1137 /* TODO: Inv Quant matrix initialisation should check if the fraction fits in 16 bits! */
1138 if (niqname[0]=='-')
1142 for (i=0; i<64; i++)
1144 inter_q[i] = hires_nonintra_quantizer_matrix_hv[i];
1149 /* default non-intra matrix is all 16's. For *our* default we use something
1150 more suitable for domestic analog sources... which is non-standard...*/
1152 for (i=0; i<64; i++)
1154 v = quant_hfnoise_filt(default_nonintra_quantizer_matrix_hv[i],i);
1156 error("value in non-intra quant matrix invalid (after noise filt adjust)");
1162 for (i=0; i<64; i++)
1164 i_intra_q[i] = (int)(((double)IQUANT_SCALE) / ((double)intra_q[i]));
1165 i_inter_q[i] = (int)(((double)IQUANT_SCALE) / ((double)inter_q[i]));
1168 for( q = 1; q <= 112; ++q )
1170 for (i=0; i<64; i++)
1172 intra_q_tbl[q][i] = intra_q[i] * q;
1173 inter_q_tbl[q][i] = inter_q[i] * q;
1174 intra_q_tblf[q][i] = (float)intra_q_tbl[q][i];
1175 inter_q_tblf[q][i] = (float)inter_q_tbl[q][i];
1176 i_intra_q_tblf[q][i] = 1.0f/ ( intra_q_tblf[q][i] * 0.98);
1177 i_intra_q_tbl[q][i] = (IQUANT_SCALE/intra_q_tbl[q][i]);
1178 i_inter_q_tblf[q][i] = 1.0f/ (inter_q_tblf[q][i] * 0.98);
1179 i_inter_q_tbl[q][i] = (IQUANT_SCALE/inter_q_tbl[q][i] );