Author: voroshil Date: Tue Dec 5 20:42:10 2006 New Revision: 21510 Modified: trunk/DOCS/man/ru/mplayer.1 Log: Translation of "VIDEO FILTERS" section. Modified: trunk/DOCS/man/ru/mplayer.1 ============================================================================== --- trunk/DOCS/man/ru/mplayer.1 (original) +++ trunk/DOCS/man/ru/mplayer.1 Tue Dec 5 20:42:10 2006 @@ -4914,637 +4914,671 @@ . . . -.SH "VIDEO FILTERS" -Video filters allow you to modify the video stream and its properties. -The syntax is: +.SH "����� �������" +����� ������� ��������� �������� ����� ����� � ��� ��������. +��������� �����: . .TP -.B \-vf <filter1[=parameter1:parameter2:...],filter2,...> -Setup a chain of video filters. +.B \-vf <������1[=��������1:��������2:...],������2,...> +������������� ������� ����� ��������. .PP -Many parameters are optional and set to default values if omitted. -To explicitly use a default value set a parameter to '-1'. -Parameters w:h means width x height in pixels, x:y means x;y position counted -from the upper left corner of the bigger image. +������ ��������� ������������� � ������������� �������� ��-���������, ���� �������. +��� ������ ������������� �������� ��-���������, ���������� ��������, ������ '-1'. +��������� w:h �������� ������ � ������ � ��������, x:y �������� x;y �������, +������ �� �������� ������ ���� �������� �����������. .br -.I NOTE: -To get a full list of available video filters, see \-vf help. +.I ���������: +������ ������ ��������� �������� ����� �������� ��� ������ \-vf help. .sp 1 -Video filters are managed in lists. -There are a few commands to manage the filter list. +����� ������� ����������� � �������. +��� ��������� ������ ���������� ������� ��������. . .TP -.B \-vf-add <filter1[,filter2,...]> -Appends the filters given as arguments to the filter list. +.B \-vf-add <������1[,������2,...]> +��������� ��������� ������� � ����� ������. . .TP -.B \-vf-pre <filter1[,filter2,...]> -Prepends the filters given as arguments to the filter list. +.B \-vf-pre <������1[,������2,...]> +��������� ��������� ������� � ������ ������. . .TP -.B \-vf-del <index1[,index2,...]> -Deletes the filters at the given indexes. -Index numbers start at 0, negative numbers address the end of the -list (-1 is the last). +.B \-vf-del <������1[,������2,...]> +������� ������� � ��������� ��������. +������� ���������� � 0, ������������� ����� �������� ������ �� +����� ������ (-1 \- ���������). . .TP .B \-vf-clr -Completely empties the filter list. +��������� ������� ������ ��������. .PP -With filters that support it, you can access parameters by their name. +��� ��� ��������, ������� ��� ������������, �� ������ �������� ������ +� �� ���������� �� ���������, . .TP -.B \-vf <filter>=help -Prints the parameter names and parameter value ranges for a particular -filter. +.B \-vf <������>=help +������� �������� � ���������� �������� ���������� ������������� �������. . .TP -.B \-vf <filter=named_parameter1=value1[:named_parameter2=value2:...]> -Sets a named parameter to the given value. -Use on and off or yes and no to set flag parameters. +.B \-vf <������=����_���������1=����1[:����_���������2=����2:...]> +������������� �������� ����������, ��������� �� ��������. +����������� on � off ��� yes � no ��� ��������� �������� ����������\-������. .PP -Available filters are: +��������� �������: . .TP .B crop[=w:h:x:y] -Crops the given part of the image and discards the rest. -Useful to remove black bands from widescreen movies. +�������� ����������� �� ���������� �������, ���������� ���������. +������� ��� �������� ������ ����� � �������������� �������. .PD 0 .RSs .IPs <w>,<h> -Cropped width and height, defaults to original width and height. +������ ���������, ��-��������� ����� �������� ������ � ������. .IPs <x>,<y> -Position of the cropped picture, defaults to center. +������� ����������� �����������, ��-��������� \- � ������. .RE .PD 1 . .TP -.B cropdetect[=limit:round] -Calculates necessary cropping parameters and prints the recommended parameters -to stdout. +.B cropdetect[=������:����������] +������������ ����������� ��������� ��������� � ������� ������������� �� +����������� �����. .PD 0 .RSs -.IPs <limit> -Threshold, which can be optionally specified from nothing (0) to -everything (255) (default: 24). +.IPs <������> +�����, ������� ����������� ����� ���� ���������� �� ������ (0) �� +��� (255) (��-���������: 24). .br -.IPs <round> -Value which the width/\:height should be divisible by (default: 16). -The offset is automatically adjusted to center the video. -Use 2 to get only even dimensions (needed for 4:2:2 video). -16 is best when encoding to most video codecs. +.IPs <����������> +��������, �� ������� ������ �������� ������/\:������ (��-���������: 16). +�������� ������������� �������������� ��� ������������� �����. +����������� 2 ��� ��������� ������ ������ �������� (����� ��� 4:2:2 �����), +16 \- ������ �������� ��� ����������� ����� �������. .RE .PD 1 . .TP .B rectangle[=w:h:x:y] -The plugin responds to the input.conf directive 'change_rectangle' -that takes two parameters. +������, ����������� �� ��������� 'change_rectangle' ����� input.conf, +����������� ��� ���������. .PD 0 .RSs .IPs <w>,<h> -width and height (default: -1, maximum possible width where boundaries -are still visible.) +������ � ������ (��-���������: -1, ����������� ��������� ����� ��� ������� ��� +����� �������.) .IPs <x>,<y> -top left corner position (default: -1, uppermost leftmost) +��������� �������� ������ ���� (��-���������: -1, ����� �������, ����� ����� ���������) .RE .PD 1 . .TP .B expand[=w:h:x:y:o:a:r] -Expands (not scales) movie resolution to the given value and places the -unscaled original at coordinates x, y. -Can be used for placing subtitles/\:OSD in the resulting black bands. +��������� (�� ������������) ���������� ������ �� ���������� �������� +� �������� ������������������ �������� � ������� x, y. +����� �������������� ��� ���������� ���������/\:OSD �� ������������ +����� �������. .RSs .IPs <w>,<h> -Expanded width,height (default: original width,height). -Negative values for w and h are treated as offsets to the original size. +������ � ������ �� ������� ���������� ���������� (��-���������: ����������� +������,������). +������������� �������� ��� w � h �������������� ��� ���������� �� ������������� �������. .sp 1 -.I EXAMPLE: +.I ������: .PD 0 .RSs .IP expand=0:-50:0:0 -Adds a 50 pixel border to the bottom of the picture. +��������� 50 ���������� ������ � ������ ����� �����������. .RE .PD 1 .IPs <x>,<y> -position of original image on the expanded image (default: center) +��������� ��������� ����������� �� ����������� (��-���������: �����) .IPs "<o>\ \ " -OSD/\:subtitle rendering +��������� OSD/\:��������� .RSss -0: disable (default) +0: ��������� (��-���������) .br -1: enable +1: �������� .REss .IPs "<a>\ \ " -Expands to fit an aspect instead of a resolution (default: 0). +����������, �������� ��������� ������ ���������� (��-���������: 0). .sp 1 -.I EXAMPLE: +.I ������: .PD 0 .RSs .IP expand=800:::::4/3 -Expands to 800x600, unless the source is higher resolution, in which -case it expands to fill a 4/3 aspect. +���������� �� 800x600, �� ����������� ������, ����� �������� �������� ����� +������� ����������, � ���� ������ ���������� �� �������, �������������� 4/3 ���������. .RE .PD 1 .IPs "<r>\ \ " -Rounds up to make both width and height divisible by <r> (default: 1). +��������� ������ ����� �������, ����� � ������, � ������ �������� �� <r> (��-���������: 1). .RE . .TP -.B flip (also see \-flip) -Flips the image upside down. +.B flip (�������� ����� \-flip) +��������� ���������� ����������� ������ ����. . .TP .B "mirror\ " -Mirrors the image on the Y axis. +��������� �������� ����������� �� ��� Y. . .TP .B rotate[=<0\-7>] -Rotates the image by 90 degrees and optionally flips it. -For values between 4\-7 rotation is only done if the movie geometry is -portrait and not landscape. +������������ ����������� �� 90 �������� � ����������� ��������� ��� ��������. +��� �������� ����� 4\-7 ������� ������������ ������ � ��� ������, ���� +����� ����� �������, � �� ��������� ����������. .RSs .IPs 0 -Rotate by 90 degrees clockwise and flip (default). +������� �� 90 �������� �� ������� ������� � ��������� (��-���������). .IPs 1 -Rotate by 90 degrees clockwise. +������� �� 90 �������� �� ������� �������. .IPs 2 -Rotate by 90 degrees counterclockwise. +������� �� 90 �������� ������ ������� �������. .IPs 3 -Rotate by 90 degrees counterclockwise and flip. +������� �� 90 �������� ������ ������� ������� � ���������. .RE . .TP .B scale[=w:h[:ilaced[:chr_drop[:par[:par2[:presize[:noup[:arnd]]]]]]]] -Scales the image with the software scaler (slow) and performs a YUV<\->RGB -colorspace conversion (also see \-sws). +������������ ����������� ������� ������������ ��������������� (��������) +� ������������ YUV<\->RGB �������������� ������������ ������ (�������� +����� \-sws). .RSs .IPs <w>,<h> -scaled width/\:height (default: original width/\:height) +������/\:������ ����� ��������������� (��-���������: ������������ ������/\:������) .br -.I NOTE: -If \-zoom is used, and underlying filters (including libvo) are -incapable of scaling, it defaults to d_width/\:d_height! +.I ���������: +.\" FIXME what does mean d_width/\:d_height +���� ������������ \-zoom, � ������� � ������ ������� (������� libvo) ���������� +��������������, �������� �� ��������� ����� d_width/\:d_height! .RSss - 0: scaled d_width/\:d_height +.\" FIXME what is d_width/\:d_height + 0: ������������������ d_width/\:d_height .br --1: original width/\:height +-1: ������������ ������/\:������ .br --2: Calculate w/h using the other dimension and the prescaled aspect ratio. +.\" FIXME prescaled is untranslated +-2: ��������� w/h, ��������� ������ ����������� � prescaled ����������� ���������. .br --3: Calculate w/h using the other dimension and the original aspect ratio. +-3: ��������� w/h, ��������� ������ ����������� � ������������ ����������� ���������. .br --(n+8): Like -n above, but rounding the dimension to the closest multiple of 16. +-(n+8): ��� � -n ����, �� �������� ������� �� ���������� �������� 16 ��������. .REss .IPs <ilaced> -Toggle interlaced scaling. +����������� ������������� ��������������. .RSss -0: off (default) +0: ��������� (��-���������) .br -1: on +1: �������� .REss .IPs <chr_drop> -chroma skipping +������� ��������� .RSss -0: Use all available input lines for chroma. +0: ������������ ��� ��������� ����� ��� ���������. .br -1: Use only every 2. input line for chroma. +1: ������������ ������ 2 ������� ����� ��� ���������. .br -2: Use only every 4. input line for chroma. +2: ������������ ������ 4 ������� ����� ��� ���������. .br -3: Use only every 8. input line for chroma. +3: ������������ ������ 8 ������� ����� ��� ���������. .REss -.IPs "<par>[:<par2>] (also see \-sws)" -Set some scaling parameters depending on the type of scaler selected -with \-sws. +.IPs "<par>[:<par2>] (�������� ����� \-sws)" +������������� ��������� ��������� ��������������� � ����������� �� +������ ���������������, ���������� � ������� \-sws. .RSss -\-sws 2 (bicubic): B (blurring) and C (ringing) +.\" FIXME is translation correct (blurring and ringing) +\-sws 2 (������������): B (����������) and C (����� �� ������� ������) .br -0.00:0.60 default +0.00:0.60 ��-��������� .br -0.00:0.75 VirtualDub's "precise bicubic" +0.00:0.75 "������ ������������" VirtualDub'� .br -0.00:0.50 Catmull-Rom spline +0.00:0.50 ������ Catmull-Rom .br -0.33:0.33 Mitchell-Netravali spline +0.33:0.33 ������ Mitchell-Netravali .br -1.00:0.00 cubic B-spline +1.00:0.00 ���������� B-������ .br -\-sws 7 (gaussian): sharpness (0 (soft) \- 100 (sharp)) +.\" FIXME is translation correct sharpen,soft,sharp +\-sws 7 (��������): �������� (0 (�����) \- 100 (�����)) .br -\-sws 9 (lanczos): filter length (1\-10) +\-sws 9 (lanczos): ����� ������� (1\-10) .REss .IPs <presize> -Scale to preset sizes. +��������������� �� ����������������� ��������. .RSss -qntsc: 352x240 (NTSC quarter screen) +qntsc: 352x240 (����� � �������� NTSC) .br -qpal: 352x288 (PAL quarter screen) +qpal: 352x288 (����� � �������� PAL) .br -ntsc: 720x480 (standard NTSC) +ntsc: 720x480 (����������� NTSC) .br -pal: 720x576 (standard PAL) +pal: 720x576 (����������� PAL) .br -sntsc: 640x480 (square pixel NTSC) +sntsc: 640x480 (NTSC � ���������� ��������) .br -spal: 768x576 (square pixel PAL) +spal: 768x576 (PAL � ���������� ��������) .REss .IPs <noup> -Disallow upscaling past the original dimensions. +������������� ���������� ������������ ������������ ��� ����������. .RSss -0: Allow upscaling (default). +0: ���������� ��������� (��-���������). .br -1: Disallow upscaling if one dimension exceeds its original value. +1: ��������� ����������, ���� ���� �� ������������ ��������� ������������ ��������. .br -2: Disallow upscaling if both dimensions exceed their original values. +2: ��������� ����������, ���� ��� ����������� ��������� ������������ ��������. .REss .IPs <arnd> -Accurate rounding for the vertical scaler, which may be faster -or slower than the default rounding. +������ ���������� ��� ������ ������������� ���������������, ������� ����� ���� +������� ��� ��������� ��� ������� ����������. .RSss -0: Disable accurate rounding (default). +0: ��������� ������ ��������� (��-���������). .br -1: Enable accurate rounding. +1: �������� ������ ����������. .REss .RE . .TP .B dsize[=aspect|w:h:aspect-method:r] -Changes the intended display size/\:aspect at an arbitrary point in the -filter chain. -Aspect can be given as a fraction (4/3) or floating point number -(1.33). -Alternatively, you may specify the exact display width and height -desired. -Note that this filter does -.B not -do any scaling itself; it just affects -what later scalers (software or hardware) will do when auto-scaling to -correct aspect. +�������� ������/\:��������� ��������������� ������ � ������������ ����� +������� ��������. ��������� ����� ���� ������ ��� ������ (4/3), ��� � +������������ ������ (1.33). ������������� �� ������ ����� ���������� +�������� ������ � ������ ������. +������ � ����, ��� ���� ������ ��� �� ���� +.B �� +������ �������� ���������������; �� ������ ������ �� ��, ��� +����������� ������ ��������������� (����������� ��� ����������) ����� ������, ����� +������������ �������������� ��������������� ��� ���������� ������ ���������. .RSs .IPs <w>,<h> -New display width and height. -Can also be these special values: +����� ������ � ������. +����� ����� ���� ������� ����������� ��������: .RSss - 0: original display width and height + 0: ������ � ������ ������������� ������� .br --1: original video width and height (default) +-1: ������ � ������ ������������� ����� (��-���������) .br --2: Calculate w/h using the other dimension and the original display -aspect ratio. +-2: ��������� w/h, ��������� ������ ����������� � ��������� ������������� �������. .br --3: Calculate w/h using the other dimension and the original video -aspect ratio. +-3: ��������� w/h, ��������� ������ ����������� � ��������� ������������� �����. .REss .sp 1 -.I EXAMPLE: +.I ������: .PD 0 .RSs .IP dsize=800:-2 -Specifies a display resolution of 800x600 for a 4/3 aspect video, or -800x450 for a 16/9 aspect video. +��������� ���������� ������, ������ 800x600 ��� 4/3 �����, ��� +800x450 ��� 16/9 �����. .RE .IPs <aspect-method> -Modifies width and height according to original aspect ratios. +�������� ������ � ������ � ������������ � ������������� �����������. .RSss --1: Ignore original aspect ratio (default). +-1: ������������ ������������ ��������� (��-���������). .br - 0: Keep display aspect ratio by using <w> and <h> as maximum -resolution. + 0: �������� ��������� �������, ��������� <w> � <h> � �������� ������������� + ����������. .br - 1: Keep display aspect ratio by using <w> and <h> as minimum -resolution. + 1: �������� ��������� �������, ��������� <w> � <h> � �������� ������������ + ����������. .br - 2: Keep video aspect ratio by using <w> and <h> as maximum -resolution. + 2: �������� ��������� �����, ��������� <w> � <h> � �������� ������������� + ����������. .br - 3: Keep video aspect ratio by using <w> and <h> as minimum -resolution. + 3: �������� ��������� �����, ��������� <w> � <h> � �������� ������������ + ����������. .REss .sp 1 -.I EXAMPLE: +.I ������: .PD 0 .RSs .IP dsize=800:600:0 -Specifies a display resolution of at most 800x600, or smaller, in order -to keep aspect. +���������� ���������� ������� ������ �������� 800x600 ��� ������ ��� +������������� ��������� ���������. .RE .PD 1 .IPs "<r>\ \ " -Rounds up to make both width and height divisible by <r> (default: 1). +��������� ������ ����� �������, ����� � ������ � ������ �������� �� <r> (��-���������: 1). .RE . .TP .B "yuy2\ \ \ " -Forces software YV12/\:I420/\:422P to YUY2 conversion. -Useful for video cards/\:drivers with slow YV12 but fast YUY2 support. +�������������� ������������� ������������ +�������������� �� YV12/\:I420/\:422P � YUY2. +������� ��� ��������� � ��������� ���������� YV12, �� ������� YUY2. . .TP .B "yvu9\ \ \ " -Forces software YVU9 to YV12 colorspace conversion. -Deprecated in favor of the software scaler. +�������������� ������������� ������������ +�������������� �� YVU9 � YV12 ������������ ������. +�������� � ����� � ��������� ������ ������������ ���������������. . .TP .B "yuvcsp\ " -Clamps YUV color values to the CCIR 601 range without doing real conversion. +�������� �������� YUV ����� � �������� CCIR 601 ��� ��������� ��������������. . .TP .B rgb2bgr[=swap] -RGB 24/32 <\-> BGR 24/32 colorspace conversion. +�������������� ������������ ������ RGB 24/32 <\-> BGR 24/32. .PD 0 .RSs .IPs "swap\ " -Also perform R <-> B swapping. +����� �������� ������� R <-> B. .RE .PD 1 . .TP .B palette -RGB/BGR 8 \-> 15/16/24/32bpp colorspace conversion using palette. +�������������� ������������ ������ RGB/BGR 8 \-> 15/16/24/32bpp +� �������������� �������. . .TP .B format[=fourcc] -Restricts the colorspace for the next filter without doing any conversion. -Use together with the scale filter for a real conversion. +������������ ������������ ������ ��� ���������� ������� ��� ������������� +������-���� ��������������. ����������� ��������� � �������� scale +��� ��������� ��������������. .br -.I NOTE: -For a list of available formats see format=fmt=help. +.I ���������: +������ ��������� �������� �������� ��� ������ format=fmt=help. .PD 0 .RSs .IPs <fourcc> -format name like rgb15, bgr24, yv12, etc (default: yuy2) +�������� �������, �������� rgb15, bgr24, yv12 � ������ (��-���������: yuy2) .RE .PD 1 . .TP .B noformat[=fourcc] -Restricts the colorspace for the next filter without doing any conversion. -Unlike the format filter, this will allow any colorspace -.B except -the one you specify. +������������ ������������ ������ ��� ���������� ������� ��� ������������� +������-���� ��������������. � ������� �� ������� format, �� ��������� ������������ +����� ������������ ������ +.B ����� +���������� ����. .br -.I NOTE: -For a list of available formats see noformat=fmt=help. +.I ���������: +������ ��������� �������� �������� ��� ������ noformat=fmt=help. .PD 0 .RSs .IPs <fourcc> -format name like rgb15, bgr24, yv12, etc (default: yv12) +�������� �������, �������� rgb15, bgr24, yv12 � ������ (��-���������: yv12) .RE .PD 1 . .TP .B pp[=filter1[:option1[:option2...]]/[-]filter2...] (also see \-pphelp) -Enables the specified chain of postprocessing subfilters. -Subfilters must be separated by '/' and can be disabled by -prepending a '\-'. -Each subfilter and some options have a short and a long name that can be -used interchangeably, i.e.\& dr/dering are the same. -All subfilters share common options to determine their scope: +����������� ��������� ������� ����������� �������������. +���������� ������ ���� �������� '/', � ����� ���� ��������� ��������� +����� ���� '\-'. +������ ��������� � ��������� ����� ����� ��� ��������, ��� � ������� +��������, ������� ��������� ���������������, �.�. dr/dering \- ��� +���� � �� ��. +.\" FIXME is translation correct? scope = ������� �������� +��� ���������� ����� ����� �����, ������������ ������� ��������: .PD 0 .RSs .IPs a/autoq -Automatically switch the subfilter off if the CPU is too slow. +������������� �������� ���������, ���� CPU ������� ���������. .IPs c/chrom -Do chrominance filtering, too (default). +��������� ������������ ��������� � ��� ����� � ����������� ���������� (��-���������). .IPs y/nochrom -Do luminance filtering only (no chrominance). +��������� ������������ ��������� ������ ��������� ����������. .IPs n/noluma -Do chrominance filtering only (no luminance). +��������� ������������ ��������� ������ ����������� ���������� (��� ��������). .RE .PD 1 .sp 1 .RS .br -.I NOTE: -\-pphelp shows a list of available subfilters. +.I ���������: +\-pphelp ������� ������ ��������� �����������. .sp 1 -Available subfilters are +��������� ����������: .RE .RSs .IPs hb/hdeblock[:difference[:flatness]] -horizontal deblocking filter +������ ��������������� deblocking'� .RSss -<difference>: Difference factor where higher values mean -more deblocking (default: 32). +<difference>: ������ ��������, ��� ������� �������� �������� +����� ������� deblocking (��-���������: 32). .br -<flatness>: Flatness threshold where lower values mean -more deblocking (default: 39). +<flatness>: ����� �������, ��� ������� �������� �������� +����� ������� deblocking (��-���������: 39). .REss .IPs vb/vdeblock[:difference[:flatness]] -vertical deblocking filter +������ ������������� deblocking'� .RSss -<difference>: Difference factor where higher values mean -more deblocking (default: 32). +<difference>: ������ ��������, ��� ������� �������� �������� +����� ������� deblocking (��-���������: 32). .br -<flatness>: Flatness threshold where lower values mean -more deblocking (default: 39). +<flatness>: ����� �������, ��� ������� �������� �������� +����� ������� deblocking (��-���������: 39). .REss .IPs ha/hadeblock[:difference[:flatness]] -accurate horizontal deblocking filter +������ ����������� ��������������� deblocking'� .RSss -<difference>: Difference factor where higher values mean -more deblocking (default: 32). +<difference>: ������ ��������, ��� ������� �������� �������� +����� ������� deblocking (��-���������: 32). .br -<flatness>: Flatness threshold where lower values mean -more deblocking (default: 39). +<flatness>: ����� �������, ��� ������� �������� �������� +����� ������� deblocking (��-���������: 39). .REss .IPs va/vadeblock[:difference[:flatness]] -accurate vertical deblocking filter +������ ����������� ������������� deblocking'� .RSss -<difference>: Difference factor where higher values mean -more deblocking (default: 32). +<difference>: ������ ��������, ��� ������� �������� �������� +����� ������� deblocking (��-���������: 32). .br -<flatness>: Flatness threshold where lower values mean -more deblocking (default: 39). +<flatness>: ����� �������, ��� ������� �������� �������� +����� ������� deblocking (��-���������: 39). .REss .sp 1 -The horizontal and vertical deblocking filters share the -difference and flatness values so you cannot set -different horizontal and vertical thresholds. +������� ��������������� � ������������� deblocking'� +���������� ����� �������� difference � flatness, ��� ��� +�� �� ������ ���������� ��������� �������������� � ������������ +������. .sp 1 .IPs h1/x1hdeblock -experimental horizontal deblocking filter +����������������� ������ ��������������� deblocking'� .IPs v1/x1vdeblock -experimental vertical deblocking filter +����������������� ������ ������������� deblocking'� .IPs dr/dering -deringing filter -.IPs tn/tmpnoise[:threshold1[:threshold2[:threshold3]]] -temporal noise reducer +������ �������� ������ �� ������� ������ +.IPs tn/tmpnoise[:�����[:�����2[:�����3]]] +��������� ������ �������������� .RSss -<threshold1>: larger -> stronger filtering +<�����1>: ������ -> ������� ���������� .br -<threshold2>: larger -> stronger filtering +<�����2>: ������ -> ������� ���������� .br -<threshold3>: larger -> stronger filtering +<�����3>: ������ -> ������� ���������� .REss .IPs al/autolevels[:f/fullyrange] -automatic brightness / contrast correction +�������������� ��������� ������� / ������������� .RSss -f/fullyrange: Stretch luminance to (0\-255). +f/fullyrange: ����������� ��������� ���������� �� (0\-255). .REss .IPs lb/linblenddeint -Linear blend deinterlacing filter that deinterlaces the given block -by filtering all lines with a (1 2 1) filter. +�������� ������ ��������������� blend, ����������� ��������������� ��������� +����� �������� ��� ����� �������� (1 2 1). .IPs li/linipoldeint -Linear interpolating deinterlacing filter that deinterlaces the given block -by linearly interpolating every second line. +�������� ������ ��������������� �������������, ����������� ��������������� ��������� +����� ������� ������������ ������ ������ �����. .IPs ci/cubicipoldeint -Cubic interpolating deinterlacing filter deinterlaces the given block -by cubically interpolating every second line. +���������� ������ ��������������� �������������, ����������� ��������������� ��������� +����� ��������� ������������ ������ ������ �����. .IPs md/mediandeint -Median deinterlacing filter that deinterlaces the given block -by applying a median filter to every second line. +������ ��������������� median, ����������� ��������������� ��������� +�����, �������� ������ median � ������ ������ �����. .IPs fd/ffmpegdeint -FFmpeg deinterlacing filter that deinterlaces the given block -by filtering every second line with a (-1 4 2 4 -1) filter. +������ ��������������� FFmpeg, ����������� ��������������� ��������� +����� �������� ������ ������ ����� �������� (-1 4 2 4 -1). .IPs l5/lowpass5 -Vertically applied FIR lowpass deinterlacing filter that deinterlaces -the given block by filtering all lines with a (-1 2 6 2 -1) filter. +����������� ����������� �������������� ������ ��������������� FIR, +����������� ��������������� ���������, �������� ��� ����� +�������� (-1 2 6 2 -1). .IPs fq/forceQuant[:quantizer] -Overrides the quantizer table from the input with the constant -quantizer you specify. +�������������� ������� ����������� ��������� ��������� ���� ���������� +�������������. .RSss -<quantizer>: quantizer to use +<quantizer>: ������������ ������������ .REss .IPs de/default -default pp filter combination (hb:a,vb:a,dr:a) +���������� pp �������� ��-��������� (hb:a,vb:a,dr:a) .IPs fa/fast -fast pp filter combination (h1:a,v1:a,dr:a) +������� ���������� pp �������� (h1:a,v1:a,dr:a) .IPs "ac\ \ \ " high quality pp filter combination (ha:a:128:7,va:a,dr:a) +������������������ ���������� pp �������� (ha:a:128:7,va:a,dr:a) .RE .RS .sp 1 -.I EXAMPLE: +.I ������: .RE .PD 0 .RSs .IPs "\-vf pp=hb/vb/dr/al" -horizontal and vertical deblocking, deringing and automatic -brightness/\:contrast +�������������� � ������������ deblocking, ���������� ������ � +�������������� ��������� �������/\:��������� .IPs "\-vf pp=de/-al" -default filters without brightness/\:contrast correction +������� ��-��������� ��� ��������� �������/\:��������� .IPs "\-vf pp=default/tmpnoise:1:2:3" -Enable default filters & temporal denoiser. +.\" FIXME termporal denoiser = ��������� ���������� ���� +����������� ������� ��-��������� � ��������� ���������� ����. .IPs "\-vf pp=hb:y/vb:a" -Horizontal deblocking on luminance only, and switch vertical deblocking -on or off automatically depending on available CPU time. +�������������� deblocking ������ ��� ��������� ����������, � +������������� �������� ��� ��������� ������������ deblocking +� ����������� �� ������������� CPU. .RE .PD 1 . .TP -.B spp[=quality[:qp[:mode]]] -Simple postprocessing filter that compresses and decompresses the -image at several (or \- in the case of quality level 6 \- all) -shifts and averages the results. +.B spp[=��������[:qp[:�����]]] +.\" FIXME is translation correct ? +.\" Simple postprocessing filter that compresses and decompresses the +.\" image at several (or \- in the case of quality level 6 \- all) +.\" shifts and averages the results. +������� ������ ������������� ��������� � ����������� ����������� +����������� (��� \- � ������ �������� 6 \- �����) ������� � +����������� ����������. .RSs -.IPs <quality> -0\-6 (default: 3) +.IPs <��������> +0\-6 (��-���������: 3) .IPs "<qp>\ " -Force quantization parameter (default: 0, use QP from video). -.IPs <mode> -0: hard thresholding (default) -.br -1: soft thresholding (better deringing, but blurrier) -.br -4: like 0, but also use B-frames' QP (may cause flicker) -.br -5: like 1, but also use B-frames' QP (may cause flicker) +������������� ������������� �������� ����������� (��-���������: 0, +����������� QP �� �����). +.IPs <�����> +0: ������� ����������� ������ (��-���������) +.br +1: ������ ����������� ������ (������ ���������� ������, �� ������� ��������) +.br +4: ��� 0, �� ����� ���������� QP B-������ (����� �������� � ��������) +.br +5: ��� 1, �� ����� ���������� QP B-������ (����� �������� � ��������) .RE . .TP -.B uspp[=quality[:qp]] -Ultra simple & slow postprocessing filter that compresses and -decompresses the image at several (or \- in the case of quality -level 8 \- all) shifts and averages the results. -The way this differs from the behavior of spp is that uspp actually -encodes & decodes each case with libavcodec Snow, whereas spp uses -a simplified intra only 8x8 DCT similar to MJPEG. +.B uspp[=��������[:qp]] +.\" FIXME is translation correct? +.\" Ultra simple & slow postprocessing filter that compresses and +.\" decompresses the image at several (or \- in the case of quality +.\" level 8 \- all) shifts and averages the results. +������ ������� & ��������� ������ �������������, +��������� � ����������� ����������� +����������� (��� \- � ������ �������� 8 \- �����) ������� � +����������� ����������. +�� ���������� �� spp ���, ��� uspp �� ����� ���� � ������ +������ �������� & ���������� � ������� Snow �� +libavcodec, � �� ����� ��� spp ���������� ������ +���������� ���������� 8x8 DCT, ������� �� MJPEG. .RSs -.IPs <quality> -0\-8 (default: 3) +.IPs <��������> +0\-8 (��-���������: 3) .IPs "<qp>\ " -Force quantization parameter (default: 0, use QP from video). +������������� ������������� �������� ����������� (��-���������: 0, +���������� QP �� �����). .RE . .TP -.B fspp[=quality[:qp[:strength[:bframes]]]] -faster version of the simple postprocessing filter +.B fspp[=��������[:qp[:����[:bframes]]]] +����� ������� ������ �������� ������� ������������� .RSs -.IPs <quality> -4\-5 (equivalent to spp; default: 4) +.IPs <��������> +4\-5 (����, ��� � � spp; ��-���������: 4) .IPs "<qp>\ " -Force quantization parameter (default: 0, use QP from video). +������������� ������������� �������� ����������� (��-���������: 0, +���������� QP �� �����). .IPs <-15\-32> -Filter strength, lower values mean more details but also more artifacts, -while higher values make the image smoother but also blurrier (default: -0 \- PSNR optimal). +���� �������, ������� �������� �������� ������� �����������, �� ����� +������� ���������� ���������, � �� ����� ��� ������� �������� ������ +����������� ����� �������, �� �������� (��-���������: +0 \- PSNR ����������). .IPs <bframes> -0: do not use QP from B-frames (default) +0: �� ������������ QP �� B-������ (��-���������) .br -1: use QP from B-frames too (may cause flicker) +1: ������������ QP �� B-������ ���� (����� �������� � ��������) .RE . .TP -.B pp7[=qp[:mode]] -Variant of the spp filter, similar to spp=6 with 7 point DCT where -only the center sample is used after IDCT. +.B pp7[=qp[:�����]] +������� spp �������, ������� �� spp=6 � 7 �������� DCT, ��� ����� +IDCT ������������ ������ ����������� �������. .RSs .IPs <qp> -Force quantization parameter (default: 0, use QP from video). -.IPs <mode> -0: hard thresholding +������������� ������������� �������� ����������� (��-���������: 0, +���������� QP �� �����). +.IPs <�����> +0: ������� ����������� ������ .br -1: soft thresholding (better deringing, but blurrier) +1: ������ ����������� ������ (������ ���������� ������, �� ������� ��������) .br -2: medium thresholding (default, good results) +2: ������� ����������� ������ (��-���������, ������ ����������) .RE . .TP -.B qp=equation -quantization parameter (QP) change filter +.B qp=��������� +������ ��������� ��������� ����������� (QP) .RSs -.IPs <equation> -some equation like "2+2*sin(PI*qp)" +.IPs <���������> +��������� ���������, ����� "2+2*sin(PI*qp)" .RE . .TP .B "test\ \ \ " -Generate various test patterns. +���������� ��������� �������� �������. . .TP .B rgbtest -Generate an RGB test pattern useful for detecting RGB vs BGR issues. -You should see a red, green and blue stripe from top to bottom. +���������� ������ ������������ RGB, �������� ��� ����������� ������� +� RGB � BGR. +�� ������ ������ �������, ������� � ����� ������ �� ����� �� ����. . .TP -.B lavc[=quality:fps] -Fast software YV12 to MPEG-1 conversion with libavcodec for use with DVB/\:DXR3/\:IVTV. +.B lavc[=��������:fps] +������� ����������� �������������� �� YV12 � MPEG-1 � ������� libavcodec ��� +������������� � DVB/\:DXR3/\:IVTV. .RSs -.IPs <quality> +.IPs <��������> .RSss -1\-31: fixed qscale +1\-31: ������������� qscale .br -32\-: fixed bitrate in kbits +32\-: ������������� �������� � ��������� .REss .IPs <fps> -force output fps (float value) (default: 0, autodetect based on height) +������������� ������������� �������� fps (������������ �����) +(��-���������: 0, ������������ ������������� �� ������ ������) .RE . .TP -.B dvbscale[=aspect] -Set up optimal scaling for DVB cards, scaling the x axis in hardware and -calculating the y axis scaling in software to keep aspect. -Only useful together with expand and scale. +.B dvbscale[=���������] +������������� ����������� ��������������� ��� DVB ����, +���������� ��������������� �� ��� x � ����������� ������ �������� �� ��� y +��� ���������� ���������. ����� ����� ������ � ���������� � expand � scale. .RSs -.IPs <aspect> -Control aspect ratio, calculate as DVB_HEIGHT*ASPECTRATIO (default: -576*4/3=768), set it to 576*(16/9)=1024 for a 16:9 TV. +.IPs <���������> +������������ ����������� ���������, ���������� ��� DVB_HEIGHT*ASPECTRATIO (��-���������: +576*4/3=768), ��� 16:9 TV �������������� ��� � 576*(16/9)=1024. .RE .sp 1 .RS -.I EXAMPLE: +.I ������: .RE .PD 0 .RSs @@ -5555,215 +5589,232 @@ . .TP .B noise[=luma[u][t|a][h][p]:chroma[u][t|a][h][p]] -Adds noise. +��������� ���. .PD 0 .RSs .IPs <0\-100> -luma noise +��� � ��������� ���������� .IPs <0\-100> -chroma noise +��� � �������� ���������� .IPs u -uniform noise (gaussian otherwise) +������������ ��� (������� ������� �������) .IPs t -temporal noise (noise pattern changes between frames) +.\" FIXME termporal noise +��������� ��� (������� ���� �������� ����� �������) .IPs a -averaged temporal noise (smoother, but a lot slower) +.\" FIXME termporal noise +����������� ��������� ��� (����� ������, �� ���������) .IPs h -high quality (slightly better looking, slightly slower) +������� �������� (������� ����� ��������, ������� ���������) .IPs p -mix random noise with a (semi)regular pattern +���������� ��������� ����� � (�����)���������� �������� .RE .PD 1 . .TP .B denoise3d[=luma:chroma:time] -This filter aims to reduce image noise producing smooth images and making still -images really still (This should enhance compressibility.). +���� ������ ������� �� ���������� ���� �����������, ������� ���������� +�������� � ����� ����������� ����������� ������������� ������������ +(��� ������ �������� �����������.). .PD 0 .RSs .IPs <luma> -spatial luma strength (default: 4) +.\" FIXME spatial luma strength +���������������� ������������ ��������� ���������� (��-���������: 4) .IPs <chroma> -spatial chroma strength (default: 3) +.\" FIXME spatial chroma strength +���������������� ������������ �������� ���������� (��-���������: 3) .IPs <time> -temporal strength (default: 6) +.\" FIXME temporal strength +��������� ������������ (��-���������: 6) .RE .PD 1 . .TP .B hqdn3d[=luma:chroma:time] -High precision/\:quality version of the denoise3d filter. -Parameters and usage are the same. +������������/\:������������ ������ ������� denoise3d. +��������� � ������������� ����� ��. . .TP -.B eq[=brightness:contrast] (OBSOLETE) -Software equalizer with interactive controls just like the hardware -equalizer, for cards/\:drivers that do not support brightness and -contrast controls in hardware. -Might also be useful with MEncoder, either for fixing poorly captured -movies, or for slightly reducing contrast to mask artifacts and get by -with lower bitrates. +.B eq[=�������:��������] (��������) +����������� ���������� � ������������� �����������, ����������� �����������, +��� ����, �� �������������� ���������� ���������� �������� � ����������. +����� �������������� c MEncoder, ���� ��� ����������� ����� ������������ +�������, ���� ���������� ���������� ��������� ��� ������� ��������� � ��������� +�������� ���������. .PD 0 .RSs .IPs <-100\-100> -initial brightness +��������� ������� .IPs <-100\-100> -initial contrast +��������� ������������� .RE .PD 1 . .TP -.B eq2[=gamma:contrast:brightness:saturation:rg:gg:bg:weight] -Alternative software equalizer that uses lookup tables (very slow), -allowing gamma correction in addition to simple brightness -and contrast adjustment. -Note that it uses the same MMX optimized code as \-vf eq if all -gamma values are 1.0. -The parameters are given as floating point values. +.B eq2[=�����:�������������:�������:������������:rg:gg:bg:weight] +�������������� ����������� ����������, ������������ ������� ������ (����� ���������), +������������� ����������� ������ ��������� ����� � ���������� � ������� +������� � �������������. +������ � ����, ��� �� ���������� ��� �� MMX ���������������� ���, ��� +� \-vf, ���� ��� �������� ����� ����� 1.0. +��������� ����������� ��� ������������ �����. .PD 0 .RSs .IPs <0.1\-10> -initial gamma value (default: 1.0) +��������� �������� ����� (��-���������: 1.0) .IPs <-2\-2> -initial contrast, where negative values result in a +��������� �������������, ��� ������������� �������� �������� +��������������� ����������� (��-���������: 1.0) negative image (default: 1.0) .IPs <-1\-1> -initial brightness (default: 0.0) +��������� ������� (��-���������: 0.0) .IPs <0\-3> -initial saturation (default: 1.0) +��������� ������������ (��-���������: 1.0) .IPs <0.1\-10> -gamma value for the red component (default: 1.0) +�������� ����� ��� ������� ���������� (��-���������: 1.0) .IPs <0.1\-10> -gamma value for the green component (default: 1.0) +�������� ����� ��� ������� ���������� (��-���������: 1.0) .IPs <0.1\-10> -gamma value for the blue component (default: 1.0) +�������� ����� ��� ����� ���������� (��-���������: 1.0) .IPs <0\-1> -The weight parameter can be used to reduce the effect of a high gamma value on -bright image areas, e.g.\& keep them from getting overamplified and just plain -white. -A value of 0.0 turns the gamma correction all the way down while 1.0 leaves it -at its full strength (default: 1.0). +�������� weight ����� �������������� ��� ���������� ������� ������� �������� +����� �� ������� �������� �����������, �.�.\& ������������ �� ���������� +���������� � ����������� � ������� ����� ����. +�������� 0.0 ������ ����� ��������� �� ���, � �� ����� ��� 1.0 ��������� +����������� �� � ������ ���� (��-���������: 1.0). .RE .PD 1 . .TP .B hue[=hue:saturation] -Software equalizer with interactive controls just like the hardware -equalizer, for cards/\:drivers that do not support hue and -saturation controls in hardware. +����������� ���������� � ������������� �����������, ����������� �����������, +��� ����/\:���������, �� �������������� ���������� ���������� ���������� +� �������������. .PD 0 .RSs .IPs <-180\-180> -initial hue (default: 0.0) +�������� ��������� (��-���������: 0.0) .IPs <-100\-100> -initial saturation, where negative values result -in a negative chroma (default: 1.0) +��������� ������������, ��� ������������� �������� ����� � ���������� +���������� ����������� ���������� (��-���������: 1.0). .RE .PD 1 . .TP .B halfpack[=f] -Convert planar YUV 4:2:0 to half-height packed 4:2:2, downsampling luma but -keeping all chroma samples. -Useful for output to low-resolution display devices when hardware downscaling -is poor quality or is not available. -Can also be used as a primitive luma-only deinterlacer with very low CPU -usage. +����������� ��������� YUV 4:2:0 � ���������� 4:2:2 ���������� ������, ��������� +������� ������������� [downsampling] ��������� ����������, �� ����������� ��� ������ �����������. +������� ��� ������ �� ������ � ������ �����������, ����� ���������� ������ +��������������� [downscaling] ������� �������� ��� ����������. +����� ����� �������������� ��� ����������� ������ ��������������� +������ ��������� ���������� � ����� ��������� ��������� �� CPU. .PD 0 .RSs .IPs "<f>\ \ " -By default, halfpack averages pairs of lines when downsampling. -Any value different from 0 or 1 gives the default (averaging) behavior. +��-���������, halfpack ��������� ���� ����� ��� ���������� ������� ������������� +[downsampling]. ����� ��������, �������� �� 0 � 1 ���� ��������� ��-��������� (����������). .RSss -0: Only use even lines when downsampling. +0: ������������ ������ ������ ����� ��� downsampling. .br -1: Only use odd lines when downsampling. +1: ������������ ������ �������� ����� ��� downsampling. .REss .RE .PD 1 . .TP -.B ilpack[=mode] -When interlaced video is stored in YUV 4:2:0 formats, chroma -interlacing does not line up properly due to vertical downsampling of -the chroma channels. -This filter packs the planar 4:2:0 data into YUY2 (4:2:2) format with -the chroma lines in their proper locations, so that in any given -scanline, the luma and chroma data both come from the same field. +.B ilpack[=�����] +����� ������������� ����� ���������� � ������� YUV 4:2:0, +.\" FIXME is translation correct ? +.\" chroma +.\" interlacing does not line up properly due to vertical downsampling of +.\" the chroma channels. +.\" This filter packs the planar 4:2:0 data into YUY2 (4:2:2) format with +.\" the chroma lines in their proper locations, so that in any given +.\" scanline, the luma and chroma data both come from the same field. +������������ ����������� ���������� ����������� ����������� ����� �� +������� ������������� downsampling'� ����������� �������. +���� ������ ����������� ��������� 4:2:0 ������ � YUY2 (4:2:2) ������ � +������������ ������� �� �� ���������� ������, ���, ��� � ����� +������ ������ [scanline] ������ � ������� � ����� ����� +������� �� ������ � ���� �� ����. + .PD 0 .RSs -.IPs <mode> -Select the sampling mode. +.IPs <�����> +�������� ����� ������� [sampling]. .RSss -0: nearest-neighbor sampling, fast but incorrect +0: ������� `��������� ��������` [nearest-neighbor sampling], �������, �� �������� .br -1: linear interpolation (default) +1: �������� ������������ (��-���������) .REss .RE .PD 1 . .TP .B harddup -Only useful with MEncoder. -If harddup is used when encoding, it will force duplicate frames to be -encoded in the output. -This uses slightly more space, but is necessary for output to MPEG -files or if you plan to demux and remux the video stream after -encoding. -Should be placed at or near the end of the filter chain unless you -have a good reason to do otherwise. +.\" FIXME need better translation +����� ����� ������ � MEncoder. +���� ��� ����������� ������������ harddup, �� ������������� ����� +����� ������������� ������������ �� ������. +��� ���������� ���� ������ �����, �� ���������� ��� ������ � MPEG �����, +��� ���� �� ����� ����������� ���������� �������������������� � +������������������ �����. +��� ������� ��������� � ����� ����� ��� ����� � ����� ����� ������� ��������, +���� � ��� �� ������� ������� ������ ��-�������. . .TP .B softskip -Only useful with MEncoder. -Softskip moves the frame skipping (dropping) step of encoding from -before the filter chain to some point during the filter chain. -This allows filters which need to see all frames (inverse telecine, -temporal denoising, etc.) to function properly. -Should be placed after the filters which need to see all frames and -before any subsequent filters that are CPU-intensive. +����� ����� ������ � MEncoder. +Softskip ���������� ���� �����������, ������������ (�������������) ����� +�� ����� ����� �������� �������� � ��������� ����� � �������� ������� ��������. +��� ��������� ��������� �������� ��������, ������� ��������� ������ ��� +����� (�������� �������, ��������� ������ ��������������, � ��.). +��� ������� ��������� ����� ��������, ������� ��������� ������ ��� �����, � +�� ����������� ��������, ���������� ������������ CPU. . .TP .B decimate[=max:hi:lo:frac] -Drops frames that do not differ greatly from the previous frame in -order to reduce framerate. -The main use of this filter is for very-low-bitrate encoding (e.g.\& -streaming over dialup modem), but it could in theory be used for -fixing movies that were inverse-telecined incorrectly. +����������� �����, �� ������ ������������ �� ����������, ��� ��������� ������� ������. +���� ������ ������� ������� ������������ ��� ����������� � �����_������_���������� +(��������, ��������� ������� ����� �����), �� ������������ �� ����� �������������� +��� ����������� ������� � ������� ������������� �������� ���������. .PD 0 .RSs .IPs <max> -Sets the maximum number of consecutive frames which can be -dropped (if positive), or the minimum interval between -dropped frames (if negative). +��������� ������������ ���������� ������ ������ ������, ������� ����� ���� +��������� (���� �������������), ��� ����������� �������� ����� �������������� +������� (���� �������������). .IPs <hi>,<lo>,<frac> -A frame is a candidate for dropping if no 8x8 region differs by more -than a threshold of <hi>, and if not more than <frac> portion (1 -meaning the whole image) differs by more than a threshold of <lo>. -Values of <hi> and <lo> are for 8x8 pixel blocks and represent actual -pixel value differences, so a threshold of 64 corresponds to 1 unit of -difference for each pixel, or the same spread out differently over the -block. +���� �������� ���������� �� ��������, ���� ��� �� ����� ������� 8x8, +������������ �����, ��� �� ��������� �������� <hi>, � �� ����� <frac> +����� (1 �������� ��� �����������) ���������� �������, ��� �� +��������� �������� <lo>. +�������� <hi> � <lo> ����������� ��� ���������� ������ 8x8 � ������������ +����� �������� � ����������� ��������� ��������, +��� ����� 64 ������������� 1 �������� � ����������� � ������ �������, +.\" FIXME untranslated +or the same spread out differently over the block. .RE .PD 1 . .TP .B dint[=sense:level] -The drop-deinterlace (dint) filter detects and drops the first from a set -of interlaced video frames. +������ ��������������� drop-deinterlace (dint), ���������� � ����������� ������ �� ������ +������������� ����� ������. .PD 0 .RSs .IPs <0.0\-1.0> -relative difference between neighboring pixels (default: 0.1) +������������� �������� ����� ��������� ��������� (��-���������: 0.1) .IPs <0.0\-1.0> -What part of the image has to be detected as interlaced to -drop the frame (default: 0.15). +����� ����� ����������� ������ ���� ���������� ��� �������������, ����� +���� ��� �������� (��-���������: 0.15). .RE .PD 1 . .TP -.B lavcdeint (OBSOLETE) -FFmpeg deinterlacing filter, same as \-vf pp=fd +.B lavcdeint (��������) +������ ��������������� FFmpeg, ��� ��, ��� � \-vf pp=fd . .TP .B kerndeint[=thresh[:map[:order[:sharp[:twoway]]]]] @@ -5772,822 +5823,878 @@ .PD 0 .RSs .IPs <0\-255> -threshold (default: 10) +����� (��-���������: 10) .IPs <map> .RSss -0: Ignore pixels exceeding the threshold (default). +0: ������������ �������, ����������� ����� (��-���������). .br -1: Paint pixels exceeding the threshold white. +1: �������� �������, ����������� �����, ����� ������. .REss .IPs <order> .RSss -0: Leave fields alone (default). +0: �������� ���� ��� ���� (��-���������). .br -1: Swap fields. +1: �������� ������� ����. .REss .IPs <sharp> .RSss -0: Disable additional sharpening (default). +0: ��������� �������������� ���������� �������� (��-���������). .br -1: Enable additional sharpening. +1: �������� �������������� ���������� ��������. .REss .IPs <twoway> .RSss -0: Disable twoway sharpening (default). +0: ��������� ���������� [twoway] ���������� �������� (default). .br -1: Enable twoway sharpening. +1: �������� ���������� [twoway] ���������� ��������. .REss .RE .PD 1 . .TP .B unsharp[=l|cWxH:amount[:l|cWxH:amount]] -unsharp mask / gaussian blur +�������� ����� / �������� ���������� .RSs .IPs "l\ \ \ \ " -Apply effect on luma component. +��������� ������ � ��������� ����������. .IPs "c\ \ \ \ " -Apply effect on chroma components. +��������� ������ � ����������� ����������. .IPs <width>x<height> -width and height of the matrix, odd sized in both directions -(min = 3x3, max = 13x11 or 11x13, usually something between 3x3 and 7x7) +������ � ������ �������, ��������� ������� � ����� ������������. +(��� = 3x3, ���� = 13x11 ��� 11x13, ������ ���-�� ����� 3x3 � 7x7) .IPs amount -Relative amount of sharpness/\:blur to add to the image -(a sane range should be -1.5\-1.5). +������������� �������� ��������/\:���������� ������������ ����������� +(�������� �������� ����� -1.5\-1.5). .RSss -<0: blur +<0: �������� .br ->0: sharpen +>0: �������� .REss .RE . .TP .B "swapuv\ " -Swap U & V plane. +������ ������� U � V �������� [planes]. . .TP .B il[=d|i][s][:[d|i][s]] -(De)interleaves lines. -The goal of this filter is to add the ability to process interlaced images -pre-field without deinterlacing them. -You can filter your interlaced DVD and play it on a TV without breaking the -interlacing. -While deinterlacing (with the postprocessing filter) removes interlacing -permanently (by smoothing, averaging, etc) deinterleaving splits the frame into -2 fields (so called half pictures), so you can process (filter) them -independently and then re-interleave them. +.\" FIXME probably hard to translate interleave and interlace terms +.\" FIXME need additional check of translation +���������(����������) [(de)nterleaves] ������. +���� ����� ������� \- �������� ����������� ��������� ����� ������������� +����������� ��� �������� �����������. +�� ������ ���������� ��� ������������� DVD � ������������� ��� �� TV ��� +��������� ���������������. +� �� �����, ��� �������������� (� ������� ������� �������������) �������� ������� +������������� ��������� (������������, ����������� � ��� �����), ���������� +[deinterleaving] ����� ���� �� ��� ���� (����� ���������� �����������), +�������� ��� ���������� �� (��������� � ��� ������) ����������, � ����� +����� ����������. .PD 0 .RSs .IPs d -deinterleave (placing one above the other) +���������� [deinterleave] (��������� ������ �� ������) .IPs i -interleave +����������� [interleave] +] .IPs s -swap fields (exchange even & odd lines) +�������� ������� ���� (�������� ������� ������ � �������� ������) .RE .PD 1 . .TP .B fil[=i|d] -(De)interleaves lines. -This filter is very similar to the il filter but much faster, the main -disadvantage is that it does not always work. -Especially if combined with other filters it may produce randomly messed -up images, so be happy if it works but do not complain if it does not for -your combination of filters. +.\" FIXME probably hard to translate interleave and interlace terms +.\" FIXME need additional check of translation +���������(����������) [(de)nterleaving] ������. +������ ����� ����� �� il ������, �� ����������� �������, ������� �� ��� +���������� ������� � ���, ��� �� �� ������ ��������. +�� �����, �������� ���� ������������� � ������� ���������, +�������� ���������� �����������, ��� ��� ���������, ���� �� +��������, �� �� ���������, ���� � ����� ������� �������� ��� �� ���. .PD 0 .RSs .IPs d -Deinterleave fields, placing them side by side. +��������� ����, �������� �� ���� �� ������. .IPs i -Interleave fields again (reversing the effect of fil=d). +����� ���������� ���� (�������� � fil=d ��������). .RE .PD 1 . .TP .B field[=n] -Extracts a single field from an interlaced image using stride arithmetic -to avoid wasting CPU time. -The optional argument n specifies whether to extract the even or the odd -field (depending on whether n is even or odd). -. -.TP -.B detc[=var1=value1:var2=value2:...] -Attempts to reverse the 'telecine' process to recover a clean, -non-interlaced stream at film framerate. -This was the first and most primitive inverse telecine filter to be -added to MPlayer/\:MEncoder. -It works by latching onto the telecine 3:2 pattern and following it as -long as possible. -This makes it suitable for perfectly-telecined material, even in the -presence of a fair degree of noise, but it will fail in the presence -of complex post-telecine edits. -Development on this filter is no longer taking place, as ivtc, pullup, -and filmdint are better for most applications. -The following arguments (see syntax above) may be used to control -detc's behavior: +.\" FIXME is translation correct stride = ������������ +�������� ��������� ���� �� �������������� �����������, ��������� +������������ ����������, ����� �� ������� ����� CPU �������. +�������������� �������� n ��������� ������ ��� �������� +���� ����������� (� ����������� �� ����, ������ n ��� ��������). +. +.TP +.B detc[=�����1=��������1:�����2=��������2:...] +�������� �������� '�������' ��������� ��� �������������� +������� �������������� ������ � �������� ������ ������. +��� ������ � ����� ����������� ������ ��������� ��������, +����������� � MPlayer/\:MEncoder. +�� ��������, ������������ � 3:2 ������� �������� � ������ ��� ��������� �����, +��������� ��� ��������. +��� ������ ��� ���������� � ����������� "�������������" +���������, ���� ��� ������� ������������� ������ ����, �� +�� �� ���������, ���� ����������� ������� �������������� ����� +��������. +���������� ����� ������� ������ �� �������, ��������� ivtc, pullup +� filmdint ����� � ����������� ����������. +��������� ��������� (��������� �������� ����) ����� �������������� ��� +���������� ���������� ������� detc: .RSs .IPs "<dr>\ " -Set the frame dropping mode. +������������� ����� ������� ������. .RSss -0: Do not drop frames to maintain fixed output framerate (default). +0: �� ����������� ����� ��� ���������� ���������� ������� ������ �� ������ (��-���������). .br -1: Always drop a frame when there have been no drops or telecine -merges in the past 5 frames. +1: ������ ���������� ����, ����� ����� �� ������������� � �� ���� ������� ������� +��������� 5 ������. .br -2: Always maintain exact 5:4 input to output frame ratio. +2: ������ ��������� ��������� ������ �� ����� � ������, ������ ����� 5:4. .br -.I NOTE: -Use mode 1 or 2 with MEncoder. +.I ���������: +� MEncoder ����������� ����� 1 ��� 2. .REss .IPs "<am>\ " -Analysis mode. +����� �������. .RSss -0: Fixed pattern with initial frame number specified by <fr>. +0: ������������� ������ � ��������� ������� �����, ��������� ���������� <fr>. .br -1: aggressive search for telecine pattern (default) +1: ����������� ����� ������� ������� (��-���������) .REss .IPs "<fr>\ " -Set initial frame number in sequence. -0\-2 are the three clean progressive frames; 3 and 4 are the two -interlaced frames. -The default, -1, means 'not in telecine sequence'. -The number specified here is the type for the imaginary previous -frame before the movie starts. +������������� ����� ���������� ����� � ������������������. +0\-2 \- ��� ��� ������ ������������� �����; 3 � 4 \- ��� ������������� �����. +��-���������, -1, �������� '�� � ������������������ �������'. +����� ��������� ����� \- ��� ��� ������������� �����, ��������������� ������ +������. .IPs "<t0>, <t1>, <t2>, <t3>" -Threshold values to be used in certain modes. +��������� ��������, ������������ � ��������� �������. .RE . .TP .B ivtc[=1] -Experimental 'stateless' inverse telecine filter. -Rather than trying to lock on to a pattern like the detc filter does, -ivtc makes its decisions independently for each frame. -This will give much better results for material that has undergone -heavy editing after telecine was applied, but as a result it is not as -forgiving of noisy input, for example TV capture. -The optional parameter (ivtc=1) corresponds to the dr=1 option for the -detc filter, and should be used with MEncoder but not with MPlayer. -As with detc, you must specify the correct output framerate (\-ofps -24000/1001) when using MEncoder. -Further development on ivtc has stopped, as the pullup and filmdint -filters appear to be much more accurate. +����������������� ������ ��������� �������� ��� ���������� ���������. +������ ����, ����� ������������� � �������, ��� ������ ������ detc, +ivtc ��������� ������� ���������� ��� ������� �����. +��� ���� ������� ������ ����������, ��� ���������, ������������� +�������� �������������� ����� ���������� ��������, �� ��� ��������� +�� �� ��������� ������������� � ���� � ���������, �������� ��� ������� � TV. +�������������� �������� (ivtc=1) ������������� ����� dr=1 ������� +detc, � ������ �������������� � MEncoder, �� �� � MPlayer. +��� � � detc, �� ������ ������� ���������� �������� ������� ������ +(\-ofps 24000/1001), ����� ����������� ��� � MEncoder. +���������� �������� ivtc �����������, ��������� pullup � filmdint +������� �������� ����������� ����� �������. . .TP .B pullup[=jl:jr:jt:jb:sb:mp] -Third-generation pulldown reversal (inverse telecine) filter, -capable of handling mixed hard-telecine, 24000/1001 fps progressive, and 30000/1001 -fps progressive content. -The pullup filter is designed to be much more robust than detc or -ivtc, by taking advantage of future context in making its decisions. -Like ivtc, pullup is stateless in the sense that it does not lock onto -a pattern to follow, but it instead looks forward to the following -fields in order to identify matches and rebuild progressive frames. -It is still under development, but believed to be quite accurate. +������ ��������� �������� [pulldown] (��������� ��������) �������� ���������, +��������� ������������ ��������� � ������� ��������� [hard-telecine], +������������� 24000/1001 fps � ������������� 30000/1001 fps �������. +������ pullup ������������� ���� ����� �������, ��� detc ��� ivtc, +�� ���� ����� ������������ ������������ ����������� � �������� +����� �������. +��� � ivtv, pullup �� ������� �� ��������� � ��� ������, ��� ��� +����������� �� �� ������������� � �������, � ������ ����� +������� ������ �� ����������� ����, ����� ���������� ���������� � +��������� ������������� �����. +�� ��� ��� ��������� � ����������, �� �������, ��� ����� +������ ������. .RSs .IPs "jl, jr, jt, and jb" -These options set the amount of "junk" to ignore at -the left, right, top, and bottom of the image, respectively. -Left/\:right are in units of 8 pixels, while top/\:bottom are in units of -2 lines. -The default is 8 pixels on each side. -.br -.IPs "sb (strict breaks)" -Setting this option to 1 will reduce the chances of -pullup generating an occasional mismatched frame, but it may also -cause an excessive number of frames to be dropped during high motion -sequences. -Conversely, setting it to -1 will make pullup match fields more -easily. -This may help processing of video where there is slight blurring -between the fields, but may also cause there to be interlaced frames -in the output. -.br -.IPs "mp (metric plane)" -This option may be set to 1 or 2 to use a chroma -plane instead of the luma plane for doing pullup's computations. -This may improve accuracy on very clean source material, but more -likely will decrease accuracy, especially if there is chroma noise -(rainbow effect) or any grayscale video. -The main purpose of setting mp to a chroma plane is to reduce CPU load -and make pullup usable in realtime on slow machines. +��� ����� ������������� �������� ������������� "������" +�����, ������, ������ � ����� ��������������. +�����/\:������ ����������� � ��������� �� 8 ��������, � �� ����� +��� �������/\:������ � ��������� �� ��� ������. +�� ���������, 8 �������� � ������ �������. +.br +.IPs "sb (������� �������)" +��������� ���� ����� � 1 �������� ����� pullup +������������� ��������� ������������� ����, �� ����� ����� +�������� � ����������� ������������ ������ � ������ ���������� +������. +� ��������, ��� ��������� ��� � -1, pullup ����� ����� ����� +��������� ���� �� ����������. +��� ����� ������ ��������� ����� � ������ ��������� ����� ������, �� +����� ����� �������� � ��������� ������������� ������ �� ������. +.br +.IPs "mp (����������� ���������)" +��� ����� ����� ���� ���������� � 1 ��� 2 ��� +.\" FIXME chroma plane = ����������� ���������� +������������� ����������� ���������� ������ ��������� � +����������� pullup. +��� ����� ��������� �������� �� ����� ������ ���������, ��, ��������� +�����, �������� ��, ��������, ���� ������������ �������� ��� (������ ������) +��� ����� �����-����� �����. +.\" FIXME chroma plane = ����������� ���������� +������� ���������� ������ ����������� ���������� - ��������� �������� CPU +� ������� pullup ��������� ��� ������������� � �������� ������� �� +��������� �������. .REss .RS .sp 1 -.I NOTE: -Always follow pullup with the softskip filter when encoding to ensure -that pullup is able to see each frame. -Failure to do so will lead to incorrect output and will usually crash, -due to design limitations in the codec/\:filter layer. +.I ���������: +��� ����������� ������ ������������� pullup ����������� �������� softskip, +����� ���������, ��� pullup ����� �������� ������ ������ ����. +������������ ����� ������� ����� ������� �� ����� �������� ������ �� ������ +� ��������� �������� � ����� � ���� ����������� ������� ���� �������/\:��������. .REss . .TP -.B filmdint[=options] -Inverse telecine filter, similar to the pullup filter above. -It is designed to handle any pulldown pattern, including mixed soft and -hard telecine and limited support for movies that are slowed down or sped -up from their original framerate for TV. -Only the luma plane is used to find the frame breaks. -If a field has no match, it is deinterlaced with simple linear -approximation. -If the source is MPEG-2, this must be the first filter to allow -access to the field-flags set by the MPEG-2 decoder. -Depending on the source MPEG, you may be fine ignoring this advice, as -long as you do not see lots of "Bottom-first field" warnings. -With no options it does normal inverse telecine, and should be used -together with mencoder \-fps 30000/1001 \-ofps 24000/1001. -When this filter is used with mplayer, it will result in an uneven -framerate during playback, but it is still generally better than using -pp=lb or no deinterlacing at all. -Multiple options can be specified separated by /. +.B filmdint[=�����] +������ ��������� ��������, ������� �� ���������� ������ pullup. +�� ���������� ��� ��������� ����� ������� ��������, ������� +��������� ������ � ������� �������, � ������������ ��������� +������� ���������� ��� ����������� �� ��������� � �� ������������ +�������� ������ ��� TV. +.\" FIXME luma plane = ��������� ���������� +������������ ������ ��������� ���������� ��� ����������� ������ ������. +���� ���� �� ����� �����������, ��� ������������� � ���� ������� +�������� �������������. +���� ���������� �������� MPEG-2, ���� ������ ������ ���� ������, +����� ����� ������ � ������ �����, ��������������� +MPEG-2 ���������. +� ����������� �� ��������� MPEG, �� ������ �������� ������������ +��� ���������, �� ��� ���, ���� �� ������ ��������� +�������������� "Bottom-first field". +��� �������� ����� ������ ������ ������� �������� ������� � +����� �������������� � MEncoder ��������� � \-fps 30000/1001 \-ofps 24000/1001. +����� ���� ������ ������������ � MPlayer, �� ����� ����� �������� +������������ ������� ������ ��� ���������������, �� ��� �������, ��� +��� �� ����� ������������� pp=lb ��� ���������� ��������������� ������. +��������� ����� ����� ���� �������� ���� �� ����� �������� /. .RSs .IPs crop=<w>:<h>:<x>:<y> -Just like the crop filter, but faster, and works on mixed hard and soft -telecined content as well as when y is not a multiple of 4. -If x or y would require cropping fractional pixels from the chroma -planes, the crop area is extended. -This usually means that x and y must be even. +�� �� �����, ��� � ������ crop, �� �������, � �������� ��� �������� �� +��������� ������� � ������ ���������, � ����� � ������, ����� y +�� ������ 4. +���� ��� x ��� y ��������� ��������� ������� �������� � +.\" FIXME chroma plane = ����������� ���������� +����������� ���������, ������� ��������� �������������. +��� �������, ��� ��������, ��� x � y ������ ���� �������. .IPs io=<ifps>:<ofps> -For each ifps input frames the filter will output ofps frames. -The ratio of ifps/\:ofps should match the \-fps/\-ofps ratio. -This could be used to filter movies that are broadcast on TV at a frame -rate different from their original framerate. +��� ������ ifps ������ �� �����, ������ ������ ofps ������ �� ������. +�������� ifps/\:ofps ������ ��������� �� ��������� \-fps/\-ofps. +����� �������������� ��� ��������� ������� ��������������� �� TV +� �������� ������, �������� �� ������������. .IPs luma_only=<n> -If n is nonzero, the chroma plane is copied unchanged. -This is useful for YV12 sampled TV, which discards one of the chroma -fields. +.\" FIXME chroma plane = ����������� ���������� +���� n �� ����� ����, ����������� ���������� ���������� ��� ���������. +.\" FIXME sampled +������� ��� YV12 ��������������� [sampled] TV, �������������� ���� +�� ����������� �����. .IPs mmx2=<n> -On x86, if n=1, use MMX2 optimized functions, if n=2, use 3DNow! -optimized functions, otherwise, use plain C. -If this option is not specified, MMX2 and 3DNow! are auto-detected, use -this option to override auto-detection. +�� x86, ���� n=1, ������������ MMX2 ���������������� ������, ���� n=2, +������������ 3DNow! ���������������� �������, ����� ������������ +������� C. ���� ����� �� �������, MMX2 � 3DNow! ������������ �������������, +����������� ��� ����� ��� ��������� ������������� ������������� +��������. .IPs fast=<n> -The larger n will speed up the filter at the expense of accuracy. -The default value is n=3. -If n is odd, a frame immediately following a frame marked with the -REPEAT_FIRST_FIELD MPEG flag is assumed to be progressive, thus filter -will not spend any time on soft-telecined MPEG-2 content. -This is the only effect of this flag if MMX2 or 3DNow! is available. -Without MMX2 and 3DNow, if n=0 or 1, the same calculations will be used -as with n=2 or 3. -If n=2 or 3, the number of luma levels used to find the frame breaks is -reduced from 256 to 128, which results in a faster filter without losing -much accuracy. -If n=4 or 5, a faster, but much less accurate metric will be used to -find the frame breaks, which is more likely to misdetect high vertical -detail as interlaced content. +������� �������� ������� ������ ������� ����� ��������. +��������� ��-��������� �������� n=3. +���� n ��������, ��������������, ��� ����, ������ ��������������� �� +���������� MPEG ������ REPEAT_FIRST_FIELD ������, �������� +�������������, ����� ������� ������ ������ �� ������ ����� �� +MPEG-2 ���������� � ������ ���������. +��� ������������ ������ ����� �����, ���� �������� MMX2 ��� 3DNow!. +��� MMX2 � 3DNow, ���� n=0 ��� 1, ����� �������������� �� �� ����������, ��� +� � n=2 ��� 3. +���� n=2 ��� 3, ���������� ������� ��������� ����������, ������������ ��� ������ +������ ������ ����������� � 256 �� 128, ��� �������� � ��������� ��������� ��� +������������ ������ ��������. +���� n=4 ��� 5, ����� �������������� ����� �������, �� ����� ������ ������� +��� ������ ������ ������, ���, ������ �����, �������� � ���������� ����������� +����������� � ������� ������������ ������������ ��� ��������������. .IPs verbose=<n> -If n is nonzero, print the detailed metrics for each frame. -Useful for debugging. +���� n �� ����� 0, ������� ��������� ������� ��� ������� �����. +������� ��� �������. .IPs dint_thres=<n> -Deinterlace threshold. -Used during de-interlacing of unmatched frames. -Larger value means less deinterlacing, use n=256 to completely turn off -deinterlacing. -Default is n=8. +����� ���������������. +������������ ��� ��������������� ������������� ������. +������� �������� �������� ������� ��������������, ����������� +n=256 ��� ���� ������� ����������. +�� ���������, n=8. .IPs comb_thres=<n> -Threshold for comparing a top and bottom fields. -Defaults to 128. +����� ��� ��������� �������� � ������� �����. +��-���������, 128. .IPs diff_thres=<n> -Threshold to detect temporal change of a field. -Default is 128. +����� ��� ����������� ���������� ��������� ����. +��-���������, 128. .IPs sad_thres=<n> -Sum of Absolute Difference threshold, default is 64. +.\" FIXME is translation correct? +����� ����� ����������� ���������� [Sum of Absolute Difference], ��-��������� 64. .RE . .TP .B softpulldown -This filter works only correct with MEncoder and acts on the MPEG-2 flags -used for soft 3:2 pulldown (soft telecine). -If you want to use the ivtc or detc filter on movies that are partly soft -telecined, inserting this filter before them should make them more reliable. +���� ������ ��������� �������� ������ � MEncoder � ������ �� MPEG-2 �����, +�������������� ��� ������� 3:2 �������� (������� ��������). +���� �� ������ ������������ ivtc ��� detc ������ ��� ������, � �������� �������� +�������� ������ �������, ������� ����� ������� ����� ���� ������ ������� +��������� ����� �����������. . .TP -.B divtc[=options] +.B divtc[=�����] Inverse telecine for deinterlaced video. -If 3:2-pulldown telecined video has lost one of the fields or is deinterlaced -using a method that keeps one field and interpolates the other, the result is -a juddering video that has every fourth frame duplicated. -This filter is intended to find and drop those duplicates and restore the -original film framerate. -When using this filter, you must specify \-ofps that is 4/5 of -the fps of the input file and place the softskip later in the -filter chain to make sure that divtc sees all the frames. -Two different modes are available: -One pass mode is the default and is straightforward to use, -but has the disadvantage that any changes in the telecine -phase (lost frames or bad edits) cause momentary judder -until the filter can resync again. -Two pass mode avoids this by analyzing the whole video -beforehand so it will have forward knowledge about the -phase changes and can resync at the exact spot. -These passes do -.B not -correspond to pass one and two of the encoding process. -You must run an extra pass using divtc pass one before the -actual encoding throwing the resulting video away. -Use \-nosound \-ovc raw \-o /dev/null to avoid -wasting CPU power for this pass. -You may add something like crop=2:2:0:0 after divtc -to speed things up even more. -Then use divtc pass two for the actual encoding. -If you use multiple encoder passes, use divtc -pass two for all of them. -The options are: +�������� ������� ��� ���������������� �����. +���� ����� � 3:2-������� ��������� �������� ���� �� ����� ��� ��� ��� +���������� �������������� � �������������� ������, ������������ ���� +�� ����� � ���������������� ������, � ���������� ��������� �������� �����, +������� ������������� ������ ��������� ����. +���� ������ ������� ����� � ��������� ��� ��������� � ������������ +������������ ������� ������ ������. +����� ����������� ��� ������, �� ������ ������� \-ofps ������ 4/5 +�� fps ��������� ����� � ��������� ������ softskip ����� � +������� ��������, ����� divtc �������������� ����� ��� �����. +�������� ��� ��������� ������: +������� ��-��������� �������� �������������, �� ����� � �������������, +�� ����� ����������, ������������� � ���, ��� ����� ��������� +�� ����� �������� (���������� ����� ��� ������ ��������������) +��� �� �������� � ��������, ���� ������ ����� �� ����������������. +������������� ����� ��������� �������� �����, ��������������� ���������� +���� �����. ����� �������, �� ������� ����� �� ���������� ���� � +����� ������������ ������������� � ��� �� �����. +��� ������� +.B �� +����� �������� ��������� � ������� � ������� ������� �������� �����������. +�� ������ ������� �������������� ������, ��������� ������ ������ divtc +�� ����, ��� �������� ������� �����������, �������� �������������� ���������. +����������� \-nosound \-ovc raw \-o /dev/null ��� ��������� +��������� ������� ������� CPU �� ���� �������. +�� ������ ���� ������ ��������� ��������, ������� ���-�� ����� crop=2:2:0:0 ����� divtc. +����� ����������� ������ ������ divtc ��� ������������� ��������������� �����������. +���� �� ����������� �������������� �����������, ����������� ������ ������ divtc +�� ������ ������� �������� �����������. +������ �����: .RSs .IPs pass=1|2 -Use two pass mode. -.IPs file=<filename> -Set the two pass log filename (default: "framediff.log"). -.IPs threshold=<value> -Set the minimum strength the telecine pattern must have for the filter to -believe in it (default: 0.5). -This is used to avoid recognizing false pattern from the parts of the video -that are very dark or very still. -.IPs window=<numframes> -Set the number of past frames to look at when searching for pattern -(default: 30). -Longer window improves the reliability of the pattern search, but shorter -window improves the reaction time to the changes in the telecine phase. -This only affects the one pass mode. -The two pass mode currently uses fixed window that extends to both future -and past. +������������ ������������� �����. +.IPs file=<���_�����> +��������� ��� log ����� ��� �������������� ������ (��-���������: "framediff.log"). +.IPs threshold=<��������> +��������� ����������� ����, ������� ������ ����� ������ ��������, ����� +������ ��� ������� (��-���������: 0.5). +������������, ����� �������� ����������� ��������� ������� �� ����� +������ ��� ����������� ������ �����. +.IPs window=<����������_������> +��������� ���������� ���������� ������, � ������� ������ ������ +(��-���������: 30). +����� ������� ���� ����������� ������������� ������ �������, �� +����� �������� �������� ����� ������� �� ��������� ���� ��������. +������ ������ �� ������������� �����. +� ������ ������ ������������� ����� ���������� ���� �������������� +�������, ������������������ ������������ � ������, � �����. .IPs phase=0|1|2|3|4 -Sets the initial telecine phase for one pass mode (default: 0). -The two pass mode can see the future, so it is able to use the correct -phase from the beginning, but one pass mode can only guess. -It catches the correct phase when it finds it, but this option can be used -to fix the possible juddering at the beginning. -The first pass of the two pass mode also uses this, so if you save the output -from the first pass, you get constant phase result. +.\" FIXME check translation +������������� ��������� ���� �������� ��� �������������� ������ (��-���������: 0). +������������� ����� ����� �������� ������, �, ����� �������, ����� � ������ ������ +������������ ���������� ����, �� ������������� ����� ����� �� ������ ������������. +�� �������� ���������� ����, ���� ����� �� �������, �� ����� ������������ ��� �����, ����� +�������� �������� � ����� ������ ������. +������ ������ ���� ��� ����������, ��� ��� ���� �� ��������� ��� +�����, �� � ���������� �������� ���������� ����. .IPs deghost=<value> -Set the deghosting threshold (0\-255 for one pass mode, -255\-255 for two pass -mode, default 0). -If nonzero, deghosting mode is used. -This is for video that has been deinterlaced by blending the fields -together instead of dropping one of the fields. -Deghosting amplifies any compression artifacts in the blended frames, so the -parameter value is used as a threshold to exclude those pixels from -deghosting that differ from the previous frame less than specified value. -If two pass mode is used, then negative value can be used to make the -filter analyze the whole video in the beginning of pass-2 to determine -whether it needs deghosting or not and then select either zero or the -absolute value of the parameter. -Specify this option for pass-2, it makes no difference on pass-1. +.\" FIXME deghosting, blending +������������� ����� ��� deghosting (0\-255 ��� �������������� ������, -255\-255 ��� +��������������, ��-��������� 0). +���� �� ����� ����, ������������ ����� deghosting. +����������� ��� �����, � �������� ��� �������� ��������������, +������������ [blending] ���� ������ ������ ������������ ������ �� ���. +Deghosting ��������� ����� ��������� ������ � ������������ [blended] ������, +������� �������� ��������� ������������ ��� ����� ��� ���������� ����� +�������� �� �������� deghosting'�, ������� ���������� �� ����������� ����� ������, +��� �� ��������� ��������. +���� ������������ ������������� �����, �� ����� ������������ ������������� +��������, ����� ������ ��������������� ��� ����� � ������ ������� ������� +��� ����������� ����� ����� deghosting ��� ���, � ����� ������ ���� 0, +���� ���������� �������� ���������. +���������� ��� ����� ��� ������� �������, ��� ����� �� ������ �� ������ ������. .RE . .TP .B phase[=t|b|p|a|u|T|B|A|U][:v] -Delay interlaced video by one field time so that the field order -changes. -The intended use is to fix PAL movies that have been captured with the -opposite field order to the film-to-video transfer. -The options are: +����������� ��������������� �������������� ����� �� ����� +����������� ������ ����, ��� �������� � ����� ������� �����. +�������������� ������������ ��� ����������� PAL �������, ����������� +� �������� �����, ��������������� �������, ������������� ��� +��������������� ������ � �����. +������ �����: .RSs .IPs t -Capture field order top-first, transfer bottom-first. -Filter will delay the bottom field. +������� ����� ��� ������� "������� ������", ��� ��������������� - +"������ ������". +������ �������� ������ ����. .IPs b -Capture bottom-first, transfer top-first. -Filter will delay the top field. +������� ����� ��� ������� "������ ������", ��� ��������������� - +"������� ������". +������ �������� ������� ����. .IPs p -Capture and transfer with the same field order. -This mode only exists for the documentation of the other options to refer to, -but if you actually select it, the filter will faithfully do nothing ;-) +������� ����� ��� ������� � ��������������� ���������. +���� ����� ���������� ������ ��� ����, ����� �� ���� ����� ���� ��������� +� ��������� ���������������� ��������� �����. ���� �� �� ������������� ��� +��������, ������ ������������� ������ �� ����� ������ ;-) .IPs a -Capture field order determined automatically by field flags, transfer opposite. -Filter selects among t and b modes on a frame by frame basis using field flags. -If no field information is available, then this works just like u. +������� ����� ��� ������� ������������ ������������� �� ������ �����, +������� ����� ��� ��������������� ����� ��������������. +������ �������� ����� t � b ��� ������� �����, ��������� +����� �����. ���� ���������� � ����� ����������, �� �������� ����� ��� � � u. .IPs u -Capture unknown or varying, transfer opposite. -Filter selects among t and b on a frame by frame basis by analyzing the -images and selecting the alternative that produces best match between the -fields. +������� ����� ��� ������� ���������� ��� ��������, ������� ����� ��� +��������������� ����� ��������������. +������ �������� ����� t � b ��� ������� �����, ���������� +����������� � ������� �������, ������ ������ ���������� ����� ������. .IPs T -Capture top-first, transfer unknown or varying. -Filter selects among t and p using image analysis. +������� ����� ��� ������� "������� ������", ������� ����� ��� +��������������� ���������� ��� ��������. +������ �������� ����� t � p, ��������� ������ �����������. .IPs B -Capture bottom-first, transfer unknown or varying. -Filter selects among b and p using image analysis. +������� ����� ��� ������� "������ ������", ������� ����� ��� +��������������� ���������� ��� ��������. +������ �������� ����� b � p, ��������� ������ �����������. .IPs A -Capture determined by field flags, transfer unknown or varying. -Filter selects among t, b and p using field flags and image analysis. -If no field information is available, then this works just like U. -This is the default mode. +������� ����� ��� ������� ������������ �� �� ������, +������� ����� ��� ��������������� ���������� ��� ��������. +������ �������� ����� t, b � p, �������� ����� ����� � ������ +�����������. ���� ���������� ���������� � �����, �� +�������� ��� ��, ��� � � U. +��� ����� ��-���������. .IPs U -Both capture and transfer unknown or varying. -Filter selects among t, b and p using image analysis only. +���������� ��� �������� �������, �������������� ��� ��� �������, ��� � +��� ���������������. +������ �������� ����� t, b � p, ����������� ������ �� ������� �����������. .IPs v -Verbose operation. -Prints the selected mode for each frame and the average squared difference -between fields for t, b, and p alternatives. +��������� ��������. +������� ��������� ����� ��� ������� ����� � ������������������ ���������� +����� ������ ��� ��������� t, b � p. .RE . .TP .B telecine[=start] -Apply 3:2 'telecine' process to increase framerate by 20%. -This most likely will not work correctly with MPlayer, but it can -be used with 'mencoder \-fps 30000/1001 \-ofps 30000/1001 \-vf telecine'. -Both fps options are essential! -(A/V sync will break if they are wrong.) -The optional start parameter tells the filter where in the telecine -pattern to start (0\-3). +��������� 3:2 ������� ��� ���������� ������� ������ �� 20%. +� ���������� ������� ��� �������� ����������� ��� +������������� � MPlayer. �� ����� �������������� +� 'mencoder \-fps 30000/1001 \-ofps 30000/1001 \-vf telecine'. +�������� ����� fps ����� ����� �����! +(����� �������� A/V �������������, ���� ��� �������.) +�������������� �������� start ��������� �������, ��� ���������� +������ �������� (0\-3). . .TP .B tinterlace[=mode] -Temporal field interlacing \- merge pairs of frames into an interlaced -frame, halving the framerate. -Even frames are moved into the upper field, odd frames to the lower field. -This can be used to fully reverse the effect of the tfields filter (in mode 0). -Available modes are: +.\" FIXME untranslated "temporal field"! +������������ temporal field \- ���������� ���� ������ � ������������� ����, +�������� ������� ������ �����. +������ ����� ������������ � ������� ����, �������� \- � ������. +����� �������������� ��� ������ ������ �������� ������� tfields (� ������ 0). +��������� �����: .PD 0 .RSs .IPs 0 -Move odd frames into the upper field, even into the lower field, generating -a full-height frame at half framerate. +������ ����� ���������� � ������� ����, �������� \- � ������, �������� +����� ���������� ������ � ����� ������� �������� ������. .IPs 1 -Only output odd frames, even frames are dropped; height unchanged. +�������� ������ �������� �����, ������ �������������; ������ �� ��������. .IPs 2 -Only output even frames, odd frames are dropped; height unchanged. +�������� ������ ������ �����, �������� �������������; ������ �� ��������. .IPs 3 -Expand each frame to full height, but pad alternate lines with black; -framerate unchanged. +��������� ������ ���� �� ������ ������, �� �������� ����������� ������ ������, +������� ������ �� ��������. .IPs 4 -Interleave even lines from even frames with odd lines from odd frames. -Generates full-height frame at half framerate. +���������� ������ ������ ������ ������ � ��������� �������� �������� ������. +���������� ����� ������ ������ � ����� ������� �������� ������. .RE .PD 1 . .TP -.B tfields[=mode[:field_dominance]] -Temporal field separation \- split fields into frames, doubling the -output framerate. -Like the telecine filter, tfields will only work properly with -MEncoder, and only if both \-fps and \-ofps are set to the -desired (double) framerate! +.B tfields[=�����[:�������_�����]] +.\" FIXME untranslated "temporal field separation" +Temporal field separation \- ��������� ���� �� �����, +�������� �������� ������� ������. +��� � ������ telecine, tfields ����� ��������� �������� ������ � +MEncoder, � ������ ���� \-fps � \-ofps ��� ����������� � +�������� (���������) ������� ������! .PD 0 .RSs -.IPs <mode> -0: Leave fields unchanged (will jump/\:flicker). +.IPs <�����> +0: �������� ���� ����������� (����� ���������/\:�������). .br -1: Interpolate missing lines. (The algorithm used might not be so good.) +1: ��������������� ����������� ������. (������������ �������� ����� ���� +������������ �������.) .br -2: Translate fields by 1/4 pixel with linear interpolation (no jump). +.\" FIXME is translation correct? +.\" Translate fields by 1/4 pixel with linear interpolation (no jump). +2: ������������� ���� 1/4 ������� �������� ������������� (��������� �� �����). .br -4: Translate fields by 1/4 pixel with 4tap filter (higher quality) (default). -.IPs <field_dominance> --1: auto (default) -Only works if the decoder exports the appropriate information and -no other filters which discard that information come before tfields -in the filter chain, otherwise it falls back to 0 (top field first). +.\" FIXME is translation correct? +.\" Translate fields by 1/4 pixel with 4tap filter (higher quality) (default). +4: ������������� ���� 1/4 ������� 4tap �������� (����� ��������) (��-���������). +.IPs <�������_�����> +-1: ���� (��-���������) +��������, ���� ������� ������������ ��������������� ����������, � +� ������� �� tfields ��� �� ������ ������� �� ��������������, ����� +������ ������������ � ������������� ������ 0 (������� ���� ������). .br -0: top field first +0: ������� ���� ������ .br -1: bottom field first +1: ������ ���� ������ .RE .PD 1 . .TP -.B yadif=[mode[:field_dominance]] -Yet another deinterlacing filter +.B yadif=[�����[:�������_�����]] +��� ���� ������ ��������������� .PD 0 .RSs -.IPs <mode> -0: Output 1 frame for each frame. +.IPs <�����> +0: ������� 1 ���� ��� ������� �����. .br -1: Output 1 frame for each field. +1: ������� 1 ���� ��� ������� ����. .br -2: Like 0 but skips spatial interlacing check. +.\" FIXME is translation correct ? +2: ��� 0, �� ���������� ���������������� �������� ���������������. .br -3: Like 1 but skips spatial interlacing check. -.IPs <field_dominance> -Operates like tfields. +.\" FIXME is translation correct ? +3: ��� 1, �� ���������� ���������������� �������� ���������������. +.IPs <�������_�����> +�������� ���������� ��������� � tfields. .RE .PD 1 . .TP -.B mcdeint=[mode[:parity[:qp]]] -Motion compensating deinterlacer. -It needs one field per frame as input and must thus be used together -with tfields=1 or yadif=1/3 or equivalent. +.B mcdeint=[�����[:��������[:qp]]] +�������������� �������� �������������. +�� ������� ������� ������ ���� � �����, �, �������, ������ �������������� +������ � tfields=1, yadif=1/3 ��� ����������� ��������. .PD 0 .RSs -.IPs <mode> -0: fast +.IPs <�����> +0: ������� .br -1: medium +1: ������� .br -2: slow, iterative motion estimation +2: ���������, ����������� ������ �������� .br -3: extra slow, like 2 plus multiple reference frames -.IPs <parity> -0 or 1 selects which field to use (note: no autodetection yet!). +.\" FIXME untranslated " multiple reference frames"! +3: ����� ���������, ��� 2 ���� multiple reference frames +.IPs <��������> +0 ��� 1 �������� ������������ ���� (���������: ��������������� ���� �� ��������!). .IPs "<qp>\ " -Higher values should result in a smoother motion vector -field but less optimal individual vectors. +������� �������� ������ ���� ����� ������� ���� ������� ��������, +�� ����� ����������� ��������� �������. .RE .PD 1 . .TP -.B boxblur=radius:power[:radius:power] -box blur +.B boxblur=������:����[:������:����] +�������� �������� .PD 0 .RSs -.IPs <radius> -blur filter strength +.IPs <������> +���� ������� blur .IPs <power> -number of filter applications +���������� ���������� ������� .RE .PD 1 . .TP -.B sab=radius:pf:colorDiff[:radius:pf:colorDiff] -shape adaptive blur +.B sab=������:pf:�������_�_�����[:������:pf:�������_�_�����] +�������� �� ������ [shape adaptive blur] .PD 0 .RSs -.IPs <radius> -blur filter strength (~0.1\-4.0) (slower if larger) +.IPs <������> +���� ������� blur (~0.1\-4.0) (��� ������, ��� ��������) .IPs "<pf>\ " -prefilter strength (~0.1\-2.0) -.IPs <colorDiff> -maximum difference between pixels to still be considered (~0.1\-100.0) +���� ���������������� ������� (~0.1\-2.0) +.IPs <�������_�_�����> +������������ ������� ����� ���������, ��� ��� ������������ ����������� (~0.1\-100.0) .RE .PD 1 . .TP -.B smartblur=radius:strength:threshold[:radius:strength:threshold] -smart blur +.B smartblur=������:����:�����[:������:����:�����] +����� �������� .PD 0 .RSs -.IPs <radius> -blur filter strength (~0.1\-5.0) (slower if larger) -.IPs <strength> -blur (0.0\-1.0) or sharpen (-1.0\-0.0) -.IPs <threshold> -filter all (0), filter flat areas (0\-30) or filter edges (-30\-0) +.IPs <������> +���� ������� blur (~0.1\-5.0) (��� ������, ��� ���������) +.IPs <����> +�������� (0.0\-1.0) ��� �������� (-1.0\-0.0) +.IPs <�����> +.\" FIXME is translation correct flat aread = ������� ������� +������������ ��� (0), ������������ ������� ������� (0\-30) ��� ������������ +���� (-30\-0) .RE .PD 1 . .TP .B perspective=x0:y0:x1:y1:x2:y2:x3:y3:t -Correct the perspective of movies not filmed perpendicular to the screen. +���������� ����������� �������, ������ �� ��������������� ������. .PD 0 .RSs .IPs <x0>,<y0>,... -coordinates of the top left, top right, bottom left, bottom right corners +���������� �������� ������, �������� �������, ������� ������, ������� ������� +����� .IPs "<t>\ \ " -linear (0) or cubic resampling (1) +�������� (0) ��� ���������� (1) �������� [resampling] .RE .PD 1 . .TP .B "2xsai\ \ " -Scale and smooth the image with the 2x scale and interpolate algorithm. +������������ �����������, ���������� ��� ����� � ��������� �������������. . .TP .B "1bpp\ \ \ " -1bpp bitmap to YUV/\:BGR 8/\:15/\:16/\:32 conversion +�������������� 1bpp ������� ����� � YUV/\:BGR 8/\:15/\:16/\:32 . .TP -.B down3dright[=lines] -Reposition and resize stereoscopic images. -Extracts both stereo fields and places them side by side, resizing -them to maintain the original movie aspect. +.B down3dright[=�����] +�������� ��������� � ������ ����������������� �����������. +��������� ��� ������ ���� � ��������� �� ���� �� ������, +������� �� ������ ��� ���������� ��������� ������������� ������. .PD 0 .RSs -.IPs <lines> -number of lines to select from the middle of the image (default: 12) +.IPs <�����> +����� ����� ��� ������ �� �������� ����������� (��-���������: 12) .RE .PD 1 . .TP -.B bmovl=hidden:opaque:fifo -The bitmap overlay filter reads bitmaps from a FIFO and displays them -on top of the movie, allowing some transformations on the image. -Also see TOOLS/bmovl-test.c for a small bmovl test program. +.B bmovl=���������:������������:fifo +������ bitmap ������� ������ bitmap ������ �� FIFO � ���������� �� +������ �����������, �������� ��������� ��� ��������������. +��������� �������� ��������� ��� bmovl �������� � +TOOLS/bmovl-test.c. .PD 0 .RSs -.IPs <hidden> -Set the default value of the 'hidden' flag (0=visible, 1=hidden). -.IPs <opaque> -Set the default value of the 'opaque' flag (0=transparent, 1=opaque). +.IPs <���������> +������������� �������� ��-��������� ��� ����� '���������' (0=�������, 1=�������). +.IPs <������������> +������������� �������� ��-��������� ��� ����� '������������' (0=����������, 1=������������) .IPs <fifo> -path/\:filename for the FIFO (named pipe connecting 'mplayer \-vf bmovl' to the -controlling application) +����/\:���� ��� FIFO (����������� pipe, ����������� 'mplayer \-vf bmovl' � +�������������� �����������) .RE .PD 1 .sp 1 .RS -FIFO commands are: +������� FIFO: .RE .PD 0 .RSs -.IPs "RGBA32 width height xpos ypos alpha clear" -followed by width*height*4 Bytes of raw RGBA32 data. -.IPs "ABGR32 width height xpos ypos alpha clear" -followed by width*height*4 Bytes of raw ABGR32 data. -.IPs "RGB24 width height xpos ypos alpha clear" -followed by width*height*3 Bytes of raw RGB24 data. -.IPs "BGR24 width height xpos ypos alpha clear" -followed by width*height*3 Bytes of raw BGR24 data. -.IPs "ALPHA width height xpos ypos alpha" -Change alpha transparency of the specified area. -.IPs "CLEAR width height xpos ypos" -Clear area. +.IPs "RGBA32 ������ ������ x������� y������� ����� �������" +� ������������ ������*������*4 ������� ����� RGBA32 ������. +.IPs "ABGR32 ������ ������ x������� y������� ����� �������" +� ������������ ������*������*4 ������� ����� ABGR32 ������. +.IPs "RGB24 ������ ������ x������� y������� ����� �������" +� ������������ ������*������*3 ������� ����� RGB24 ������. +.IPs "BGR24 ������ ������ x������� y������� ����� �������" +� ������������ ������*������*3 ������� ����� BGR24 ������. +.IPs "ALPHA ������ ������ x������� y������� ����� �������" +�������� ����� ������������ ��������� �������. +.IPs "CLEAR ������ ������ x������� y�������" +������� �������. .IPs OPAQUE -Disable all alpha transparency. -Send "ALPHA 0 0 0 0 0" to enable it again. +��������� ��������� ����� ������������. +�������� "ALPHA 0 0 0 0 0", ����� ����� �� �������������. .IPs "HIDE\ " -Hide bitmap. +�������� bitmap. .IPs "SHOW\ " -Show bitmap. +���������� bitmap. .RE .PD 1 .sp 1 .RS -Arguments are: +���������: .RE .PD 0 .RSs -.IPs "<width>, <height>" -image/area size -.IPs "<xpos>, <ypos>" -Start blitting at position x/y. -.IPs <alpha> -Set alpha difference. -If you set this to -255 you can then send a sequence of ALPHA-commands to set -the area to -225, -200, -175 etc for a nice fade-in-effect! ;) +.IPs "<������>, <������>" +������ �����������/������� +.IPs "<x�������>, <y�������>" +�������� ����� � ������� x/y. +.IPs <�����> +������������� ���������� �����. +���� �� ���������� ��� �������� � -255, �� ������� ����� ������� ������������������ +ALPHA-������, ����� ���������� ������� � -225, -200, -175 � ��� ����� ��� +��������� fade-in-������� [�������� ����������]! ;) .RSss -0: same as original +0: ����� ��, ��� � ���� .br -255: Make everything opaque. +255: ������� ��� ������������. .br --255: Make everything transparent. +-255: ������� ��� ����������. .REss -.IPs <clear> -Clear the framebuffer before blitting. +.IPs <��������> +������� ���������� ����� �������. .RSss -0: The image will just be blitted on top of the old one, so you do not need to -send 1.8MB of RGBA32 data every time a small part of the screen is updated. +0: ����������� ����� �������� ����� ������ �������, ��� ��� ��� �� ����������� +���������� 1.8MB RGBA32 ������ ������ ��� ��� ���������� ��������� ����� ������. .br -1: clear +1: �������� .REss .RE .PD 1 . .TP .B framestep=I|[i]step -Renders only every nth frame or every intra frame (keyframe). +�������� ������ ������ n-� ���� ��� ������ intra (��������) ����. .sp 1 -If you call the filter with I (uppercase) as the parameter, then -.B only -keyframes are rendered. -For DVDs it generally means one in every 15/12 frames (IBBPBBPBBPBBPBB), -for AVI it means every scene change or every keyint value (see \-lavcopts -keyint= value if you use MEncoder to encode the video). +���� ������� ���� ������ � I (� ������� ��������) � �������� ���������, �� +.B ������ +�������� ����� ����� ����������. +��� DVD ���, ��� �������, �������� ���� �� 15/12 ������ (IBBPBBPBBPBBPBB), +��� AVI ��� ������ ������ ����� ����� ��� �������� keyint (�������� �������� +\-lavcopts keyint= , ���� ����������� MEncoder ��� ����������� �����). .sp 1 -When a keyframe is found, an 'I!' string followed by a newline character is -printed, leaving the current line of MPlayer/\:MEncoder output on the screen, -because it contains the time (in seconds) and frame number of the keyframe -(You can use this information to split the AVI.). +����� ������ �������� ����, �������� 'I!' � ����������� �������� �������� ������, +�������� ������� ������ ������ MPlayer/\:MEncoder ������� �� ������, ������ ��� +��� �������� ����� (� ��������) � ����� ��������� ����� +(�� ������ ������������ ��� ���������� ��� ���������� AVI.). .sp 1 -If you call the filter with a numeric parameter 'step' then only one in -every 'step' frames is rendered. +���� ������� ������ � �������� ���������� 'step' �� ������ ������ +'step' ���� ����� �����������. .sp 1 -If you put an 'i' (lowercase) before the number then an 'I!' is printed -(like the I parameter). +���� ����� ������ ������� 'i' (� ������ ��������), �� (��� � � I ����������) +����� ���������� 'I!'. .sp 1 -If you give only the i then nothing is done to the frames, only I! is -printed. +���� ������� ������ i, �� ������, ����� ������ I!, �������� �� �����. . .TP .B tile=xtiles:ytiles:output:start:delta -Tile a series of images into a single, bigger image. -If you omit a parameter or use a value less than 0, then the default -value is used. -You can also stop when you are satisfied (... \-vf tile=10:5 ...). -It is probably a good idea to put the scale filter before the tile :-) +����������� �������� ��������� ����������� � ����� �������� �������. +���� �� �� ���������� �������� ��� ���������� �������� ������ 0, +����� �������������� �������� ��-���������. +�� ����� ������ ������������, ����� ������������� (... \-vf tile=10:5 ...). +��������, ��������� ������ scale ����� tile ����� ������� ����� :-) .sp 1 -The parameters are: +������ ����������: .sp 1 .PD 0 .RSs .IPs <xtiles> -number of tiles on the x axis (default: 5) +���������� ��������� ������� �� ��� x (��-���������: 5) .IPs <ytiles> -number of tiles on the y axis (default: 5) +���������� ��������� ������� �� ��� y (��-���������: 5) .IPs <output> -Render the tile when 'output' number of frames are reached, where 'output' -should be a number less than xtile * ytile. -Missing tiles are left blank. -You could, for example, write an 8 * 7 tile every 50 frames to have one -image every 2 seconds @ 25 fps. +�������� �������, ����� ���������� ���������� ������ 'output', ��� 'output' +������ ���� ������, ������� xtile * ytile. +����������� �������� ������� �������� �������. +�� ������, ��������, ���������� ������� 8 * 7 ������ 50 ������, ����� +�������� ���� ����������� ������ 2 ������� ��� 25 fps. .IPs <start> -outer border thickness in pixels (default: 2) +������� ������� ������� � �������� (��-���������: 2) .IPs <delta> -inner border thickness in pixels (default: 4) +������� ���������� ������� � �������� (��-���������: 4) .RE .PD 1 . .TP .B delogo[=x:y:w:h:t] -Suppresses a TV station logo by a simple interpolation of the -surrounding pixels. -Just set a rectangle covering the logo and watch it disappear (and -sometimes something even uglier appear \- your mileage may vary). +��������� ������� TV ������ ������� ������������� ���������� ��������. +������ ������� ���������� ��������������, ������������ ������� � +���������, ��� �� ������ (� ��������� ����� ���� ����� ����������� \- +������ ���������) .PD 0 .RSs .IPs <x>,<y> -top left corner of the logo +������� ����� ���� �������� .IPs <w>,<h> -width and height of the cleared rectangle +������ � ������ �������������� .IPs <t> -Thickness of the fuzzy edge of the rectangle (added to w and h). -When set to -1, a green rectangle is drawn on the screen to -simplify finding the right x,y,w,h parameters. +������� �������� ������� �������������� (����������� � w � h). +����� ����������� � -1, �� ����� ��������� ������� ������������ ��� +���������� ������ ���������� ���������� x,y,w,h. .RE .PD 1 . .TP -.B remove-logo=/path/to/logo_bitmap_file_name.pgm -Suppresses a TV station logo, using a PGM or PPM image -file to determine which pixels comprise the logo. -The width and height of the image file must match -those of the video stream being processed. -Uses the filter image and a circular blur -algorithm to remove the logo. +.B remove-logo=/����/�/�����_�_���������.pgm +��������� ������� TV ������, ��������� PGM ��� PPM ���� +����������� ��� ����������� ��������, ������������ �������. +������ � ������ ����������� � ����� � � ��������������� ������ +������ ���������. +��� ���������� ���������� �����������\-������ � �������� ��������� +�������� [circular blur]. .RSs -.IPs /path/to/logo_bitmap_file_name.pgm -[path] + filename of the filter image. +.IPs /����/�/�����_�_���������.pgm +[����] + ��� ����� � ������������\-��������. .RE . .TP -.B zrmjpeg[=options] -Software YV12 to MJPEG encoder for use with the zr2 video -output device. +.B zrmjpeg[=�����] +����������� ���������� YV12 � MJPEG ��� ������������� ��������� � ��������� +������ ����� zr2. .RSs .IPs maxheight=<h>|maxwidth=<w> -These options set the maximum width and height the zr card -can handle (the MPlayer filter layer currently cannot query those). +��� ����� ������������� ������������ ������� � ������ ������� ����� +������������ zr ����� (�� ������� ������ ������� �������� MPlayer �� +����� �� �����������). .IPs {dc10+,dc10,buz,lml33}-{PAL|NTSC} -Use these options to set maxwidth and maxheight automatically to the -values known for card/\:mode combo. -For example, valid options are: dc10-PAL and buz-NTSC (default: dc10+PAL) +����������� ��� ����� ��� �������������� ��������� maxwidth � maxheight +� ��������, ��������� ��� ���������� �����/\:�����. +������ �����, ��������: dc10-PAL � buz-NTSC (��-���������: dc10+PAL) .IPs color|bw -Select color or black and white encoding. -Black and white encoding is faster. -Color is the default. +�������� ������� ��� �����\-����� �����������. +�����-����� �������� �������. +��-��������� \- �������. .IPs hdec={1,2,4} -Horizontal decimation 1, 2 or 4. +�������������� ������������ 1, 2 ��� 4. .IPs vdec={1,2,4} -Vertical decimation 1, 2 or 4. +������������ ������������ 1, 2 ��� 4. .IPs quality=1\-20 -Set JPEG compression quality [BEST] 1 \- 20 [VERY BAD]. +������������� �������� JPEG ������ [���������] 1 \- 20 [����� ������]. .IPs fd|nofd -By default, decimation is only performed if the Zoran hardware -can upscale the resulting MJPEG images to the original size. -The option fd instructs the filter to always perform the requested -decimation (ugly). +��-���������, ������������ ������������, ������ ���� ������������ Zoran +����� ���������������� ������������ MJPEG ����������� �� ������������� +�������. ����� fd ��������� ������� ������ ����������� +����������� ������������ (����������). .RE . .TP .B screenshot -Allows acquiring screenshots of the movie using slave mode -commands that can be bound to keypresses. -See the slave mode documentation and the INTERACTIVE CONTROL -section for details. -Files named 'shotNNNN.png' will be saved in the working directory, -using the first available number - no files will be overwritten. -The filter has no overhead when not used and accepts an arbitrary -colorspace, so it is safe to add it to the configuration file. +��������� ����������� ��������� ������, � ������� +������ ������������ ������, ������� ����� ��������� � +����������� ������. ����������� �������� � ������������ +�� ������������ ������ � ������� ������������� ����������. +� ������� ������� ����� �������� ����� 'shotNNNN.png', ������� � +������� ���������� ������ - ������������ ����� �� ����������������. +������ �� ������ ��������� ��������, ����� �� ������������, � �������� � +����� ������������� ������, ��� ��� ��� �������� ����� �������� � +���� ������������. .RE . .TP .B "ass\ \ \ \ " -Moves SSA/ASS subtitle rendering to an arbitrary point in the filter chain. -Only useful with the \-ass option. +�������� ��������� SSA/ASS ��������� � ��������� ����� ������� ��������. +����� ����� ������ � ������ \-ass. .sp 1 -.I EXAMPLE: +.I ������: .PD 0 .RSs .IPs "\-vf ass,screenshot" -Moves SSA/ASS rendering before the screenshot filter. -Screenshots taken this way will contain subtitles. +�������� ��������� SSA/ASS ����� �������� screenshot. +���������, ���������� ����� ��������, ����� ��������� ��������. .RE .PD 1 . .TP -.B blackframe[=amount:threshold] -Detect frames that are (almost) completely black. -Can be useful to detect chapter transitions or commercials. -Output lines consist of the frame number of the detected frame, the -percentage of blackness, the frame type and the frame number of the last -encountered keyframe. +.B blackframe[=����������:�����] +������� (�����) ��������� ������ �����. +����� �������������� ��� ����������� ��������� ����� ������� ��� �������. +��������� ����� �������� ����� ���������� �����, ������� �������, +��� ����� � ����� ���������� �������������� ��������� �����. .RSs -.IPs <amount> -Percentage of the pixels that have to be below the threshold (default: 98). -.IPs <threshold> -Threshold below which a pixel value is considered black (default: 32). +.IPs <����������> +���������� �������� � ���������, �������� ������� ������ ���� ���� ���������� +(��-���������: 98). +.IPs <�����> +�����, ���� �������� �������� ������� ��������� ������ (��-���������: 32). .RE . .
participants (1)
-
voroshil