Fix checkstyle violations for Google Java Style

Fix all checkstyle warnings when using google_checks.xml:
- NeedBraces: add braces to single-line if/else/for blocks
- AvoidStarImport: replace wildcard imports with explicit ones
- SummaryJavadoc: add periods to Javadoc summary sentences
- MissingJavadocType: add Javadoc to all public types
- MissingJavadocMethod: add Javadoc to all public methods
- LineLength: wrap lines exceeding 100 characters
- OverloadMethodsDeclarationOrder: group overloaded methods
- JavadocTagContinuationIndentation: fix tag indentation
- AtclauseOrder: reorder @param/@return/@throws tags
- VariableDeclarationUsageDistance: move declarations closer to usage
- Remove @SuppressFBWarnings annotations (use exclude file instead)
- Add checkstyle-suppressions.xml for intentional naming deviations

Author: bramp

src/main/java/net/bramp/commons/lang3/math/gson/FractionAdapter.java

@@ -26,6 +26,7 @@ public class FractionAdapter extends TypeAdapter<Fraction> {
       "Immutable") // TODO Remove when https://github.com/google/error-prone/issues/512 is fixed
   private final Fraction divideByZero;
 
+  /** Constructs a FractionAdapter with default zero values for edge cases. */
   public FractionAdapter() {
     this(Fraction.ZERO, Fraction.ZERO);
   }

src/main/java/net/bramp/ffmpeg/FFmpeg.java

@@ -95,18 +95,22 @@ public class FFmpeg extends FFcommon {
   /** Supported channel layouts. */
   private List<ChannelLayout> channelLayouts = null;
 
+  /** Constructs an FFmpeg instance using the default path. */
   public FFmpeg() throws IOException {
     this(DEFAULT_PATH, new RunProcessFunction());
   }
 
+  /** Constructs an FFmpeg instance using the default path and the specified process function. */
   public FFmpeg(@Nonnull ProcessFunction runFunction) throws IOException {
     this(DEFAULT_PATH, runFunction);
   }
 
+  /** Constructs an FFmpeg instance using the specified path. */
   public FFmpeg(@Nonnull String path) throws IOException {
     this(path, new RunProcessFunction());
   }
 
+  /** Constructs an FFmpeg instance using the specified path and process function. */
   @SuppressWarnings("this-escape")
   public FFmpeg(@Nonnull String path, @Nonnull ProcessFunction runFunction) throws IOException {
     super(path, runFunction);
@@ -287,6 +291,7 @@ public synchronized List<ChannelLayout> channelLayouts() throws IOException {
     return this.channelLayouts;
   }
 
+  /** Creates a progress parser for the given listener. */
   protected ProgressParser createProgressParser(ProgressListener listener) throws IOException {
     // TODO In future create the best kind for this OS, unix socket, named pipe, or TCP.
     try {
@@ -331,6 +336,7 @@ public void run(FFmpegBuilder builder, @Nullable ProgressListener listener) thro
     }
   }
 
+  /** Returns a new FFmpegBuilder instance. */
   @CheckReturnValue
   public FFmpegBuilder builder() {
     return new FFmpegBuilder();

src/main/java/net/bramp/ffmpeg/FFmpegException.java

@@ -9,6 +9,7 @@ public class FFmpegException extends IOException {
   private static final long serialVersionUID = 3048288225568984942L;
   private final FFmpegError error;
 
+  /** Constructs an FFmpegException with the specified message and error details. */
   public FFmpegException(String message, FFmpegError error) {
     super(message);
     this.error = error;

src/main/java/net/bramp/ffmpeg/FFmpegExecutor.java

@@ -15,23 +15,28 @@ public class FFmpegExecutor {
   final FFmpeg ffmpeg;
   final FFprobe ffprobe;
 
+  /** Constructs an FFmpegExecutor using default FFmpeg and FFprobe instances. */
   public FFmpegExecutor() throws IOException {
     this(new FFmpeg(), new FFprobe());
   }
 
+  /** Constructs an FFmpegExecutor with the specified FFmpeg instance. */
   public FFmpegExecutor(FFmpeg ffmpeg) throws IOException {
     this(ffmpeg, new FFprobe());
   }
 
+  /** Constructs an FFmpegExecutor with the specified FFmpeg and FFprobe instances. */
   public FFmpegExecutor(FFmpeg ffmpeg, FFprobe ffprobe) {
     this.ffmpeg = checkNotNull(ffmpeg);
     this.ffprobe = checkNotNull(ffprobe);
   }
 
+  /** Creates a single-pass FFmpeg job from the given builder. */
   public FFmpegJob createJob(FFmpegBuilder builder) {
     return new SinglePassFFmpegJob(ffmpeg, builder);
   }
 
+  /** Creates a single-pass FFmpeg job with a progress listener. */
   public FFmpegJob createJob(FFmpegBuilder builder, ProgressListener listener) {
     return new SinglePassFFmpegJob(ffmpeg, builder, listener);
   }
@@ -47,6 +52,7 @@ public FFmpegJob createTwoPassJob(FFmpegBuilder builder) {
     return new TwoPassFFmpegJob(ffmpeg, builder);
   }
 
+  /** Creates a two-pass FFmpeg job with a progress listener. */
   public FFmpegJob createTwoPassJob(FFmpegBuilder builder, ProgressListener listener) {
     return new TwoPassFFmpegJob(ffmpeg, builder, listener);
   }

src/main/java/net/bramp/ffmpeg/FFprobe.java

@@ -30,35 +30,43 @@ public class FFprobe extends FFcommon {
 
   static final Gson gson = FFmpegUtils.getGson();
 
+  /** Constructs an FFprobe instance using the default path. */
   public FFprobe() throws IOException {
     this(DEFAULT_PATH, new RunProcessFunction());
   }
 
+  /** Constructs an FFprobe instance using the default path and the specified process function. */
   public FFprobe(@Nonnull ProcessFunction runFunction) throws IOException {
     this(DEFAULT_PATH, runFunction);
   }
 
+  /** Constructs an FFprobe instance using the specified path. */
   public FFprobe(@Nonnull String path) throws IOException {
     this(path, new RunProcessFunction());
   }
 
+  /** Constructs an FFprobe instance using the specified path and process function. */
   public FFprobe(@Nonnull String path, @Nonnull ProcessFunction runFunction) {
     super(path, runFunction);
   }
 
+  /** Probes the specified media file and returns the result. */
   public FFmpegProbeResult probe(String mediaPath) throws IOException {
     return probe(mediaPath, null);
   }
 
+  /** Probes the specified media file with an optional user agent. */
   public FFmpegProbeResult probe(String mediaPath, @Nullable String userAgent) throws IOException {
     return probe(this.builder().setInput(mediaPath).setUserAgent(userAgent));
   }
 
+  /** Probes media using the supplied FFprobeBuilder. */
   public FFmpegProbeResult probe(FFprobeBuilder builder) throws IOException {
     checkNotNull(builder);
     return probe(builder.build());
   }
 
+  /** Probes media with an optional user agent and extra arguments. */
   public FFmpegProbeResult probe(
       String mediaPath, @Nullable String userAgent, @Nullable String... extraArgs)
       throws IOException {
@@ -123,6 +131,7 @@ public void run(List<String> args) throws IOException {
     super.run(args);
   }
 
+  /** Returns a new FFprobeBuilder instance. */
   @CheckReturnValue
   public FFprobeBuilder builder() {
     return new FFprobeBuilder();

src/main/java/net/bramp/ffmpeg/ProcessFunction.java

@@ -9,5 +9,6 @@
  * @author bramp
  */
 public interface ProcessFunction {
+  /** Runs a process with the given arguments and returns the process handle. */
   Process run(List<String> args) throws IOException;
 }

src/main/java/net/bramp/ffmpeg/RunProcessFunction.java

@@ -37,11 +37,13 @@ public Process run(List<String> args) throws IOException {
     return builder.start();
   }
 
+  /** Sets the working directory for the process using a path string. */
   public RunProcessFunction setWorkingDirectory(String workingDirectory) {
     this.workingDirectory = new File(workingDirectory);
     return this;
   }
 
+  /** Sets the working directory for the process using a File object. */
   public RunProcessFunction setWorkingDirectory(File workingDirectory) {
     this.workingDirectory = workingDirectory;
     return this;

src/main/java/net/bramp/ffmpeg/builder/AbstractFFmpegInputBuilder.java

@@ -18,16 +18,19 @@ public abstract class AbstractFFmpegInputBuilder<T extends AbstractFFmpegInputBu
    */
   private int streamLoop;
 
+  /** Constructs an input builder with the given parent and filename. */
   protected AbstractFFmpegInputBuilder(FFmpegBuilder parent, String filename) {
     this(parent, null, filename);
   }
 
+  /** Constructs an input builder with the given parent, probe result, and filename. */
   protected AbstractFFmpegInputBuilder(
       FFmpegBuilder parent, FFmpegProbeResult probeResult, String filename) {
     super(parent, filename);
     this.probeResult = probeResult;
   }
 
+  /** Enables reading input at native frame rate. */
   public T readAtNativeFrameRate() {
     this.readAtNativeFrameRate = true;
     return getThis();

src/main/java/net/bramp/ffmpeg/builder/AbstractFFmpegOutputBuilder.java

@@ -110,14 +110,17 @@ public abstract class AbstractFFmpegOutputBuilder<T extends AbstractFFmpegOutput
 
   protected String complexFilter;
 
+  /** Constructs a default output builder. */
   public AbstractFFmpegOutputBuilder() {
     super();
   }
 
+  /** Constructs an output builder with the given parent and filename. */
   protected AbstractFFmpegOutputBuilder(FFmpegBuilder parent, String filename) {
     super(parent, filename);
   }
 
+  /** Constructs an output builder with the given parent and URI. */
   protected AbstractFFmpegOutputBuilder(FFmpegBuilder parent, URI uri) {
     super(parent, uri);
   }
@@ -145,6 +148,7 @@ public T setVideoQuality(double quality) {
     return (T) this;
   }
 
+  /** Sets the video bit stream filter. */
   public T setVideoBitStreamFilter(String filter) {
     this.video_bit_stream_filter = checkNotEmpty(filter, "filter must not be empty");
     return (T) this;

src/main/java/net/bramp/ffmpeg/builder/AbstractFFmpegStreamBuilder.java

@@ -106,52 +106,63 @@ public abstract class AbstractFFmpegStreamBuilder<T extends AbstractFFmpegStream
 
   public boolean throwWarnings = true; // TODO Either delete this, or apply it consistently
 
+  /** Constructs a stream builder with no parent. */
   protected AbstractFFmpegStreamBuilder() {
     this.parent = null;
   }
 
+  /** Constructs a stream builder with the given parent and output filename. */
   protected AbstractFFmpegStreamBuilder(FFmpegBuilder parent, String filename) {
     this.parent = checkNotNull(parent);
     this.filename = checkNotEmpty(filename, "filename must not be empty");
   }
 
+  /** Constructs a stream builder with the given parent and output URI. */
   protected AbstractFFmpegStreamBuilder(FFmpegBuilder parent, URI uri) {
     this.parent = checkNotNull(parent);
     this.uri = checkValidStream(uri);
   }
 
+  /** Returns this instance for fluent API chaining. */
   protected abstract T getThis();
 
+  /** Applies the given encoding options to this builder. */
   public T useOptions(EncodingOptions opts) {
     Mapper.map(opts, this);
     return getThis();
   }
 
+  /** Applies the given main encoding options to this builder. */
   public T useOptions(MainEncodingOptions opts) {
     Mapper.map(opts, this);
     return getThis();
   }
 
+  /** Applies the given audio encoding options to this builder. */
   public T useOptions(AudioEncodingOptions opts) {
     Mapper.map(opts, this);
     return getThis();
   }
 
+  /** Applies the given video encoding options to this builder. */
   public T useOptions(VideoEncodingOptions opts) {
     Mapper.map(opts, this);
     return getThis();
   }
 
+  /** Disables video output. */
   public T disableVideo() {
     this.video_enabled = false;
     return getThis();
   }
 
+  /** Disables audio output. */
   public T disableAudio() {
     this.audio_enabled = false;
     return getThis();
   }
 
+  /** Disables subtitle output. */
   public T disableSubtitle() {
     this.subtitle_enabled = false;
     return getThis();
@@ -207,6 +218,7 @@ public T setPreset(String preset) {
     return getThis();
   }
 
+  /** Sets the output filename. */
   public T setFilename(String filename) {
     this.filename = checkNotEmpty(filename, "filename must not be empty");
     return getThis();
@@ -232,10 +244,12 @@ public T setFilename(Path path) {
     return setFilename(checkNotNull(path).toString());
   }
 
+  /** Returns the output filename. */
   public String getFilename() {
     return filename;
   }
 
+  /** Sets the output URI. */
   public T setUri(URI uri) {
     this.uri = checkValidStream(uri);
     return getThis();
@@ -317,6 +331,7 @@ public T setFrames(int frames) {
     return getThis();
   }
 
+  /** Checks if the given width or height value is valid. */
   protected static boolean isValidSize(int widthOrHeight) {
     return widthOrHeight > 0 || widthOrHeight == -1;
   }
@@ -527,6 +542,7 @@ public T setDuration(long duration, TimeUnit units) {
     return getThis();
   }
 
+  /** Sets the strict mode for standards compliance. */
   public T setStrict(Strict strict) {
     this.strict = checkNotNull(strict);
     return getThis();
@@ -607,6 +623,7 @@ public FFmpegBuilder done() {
    */
   public abstract EncodingOptions buildOptions();
 
+  /** Builds the command-line arguments for the given pass using the parent builder. */
   protected List<String> build(int pass) {
     Preconditions.checkState(parent != null, "Can not build without parent being set");
     return build(parent, pass);
@@ -659,8 +676,10 @@ protected List<String> build(FFmpegBuilder parent, int pass) {
     return args.build();
   }
 
+  /** Adds source and target specific arguments for the given pass. */
   protected abstract void addSourceTarget(int pass, ImmutableList.Builder<String> args);
 
+  /** Adds global flags such as format, preset, and time options to the arguments. */
   protected void addGlobalFlags(FFmpegBuilder parent, ImmutableList.Builder<String> args) {
     if (strict != Strict.NORMAL) {
       args.add("-strict", strict.toString());
@@ -689,6 +708,7 @@ protected void addGlobalFlags(FFmpegBuilder parent, ImmutableList.Builder<String
     args.addAll(meta_tags);
   }
 
+  /** Adds audio-related flags such as codec, channels, and sample rate to the arguments. */
   protected void addAudioFlags(ImmutableList.Builder<String> args) {
     if (!Strings.isNullOrEmpty(audio_codec)) {
       args.add("-acodec", audio_codec);
@@ -707,6 +727,7 @@ protected void addAudioFlags(ImmutableList.Builder<String> args) {
     }
   }
 
+  /** Adds video-related flags such as codec, frame rate, and resolution to the arguments. */
   protected void addVideoFlags(FFmpegBuilder parent, ImmutableList.Builder<String> args) {
     if (video_frames != null) {
       args.add("-vframes", video_frames.toString());
@@ -745,6 +766,7 @@ protected void addVideoFlags(FFmpegBuilder parent, ImmutableList.Builder<String>
     }
   }
 
+  /** Adds format-related arguments such as stream mappings. */
   protected void addFormatArgs(ImmutableList.Builder<String> args) {
     for (String map : maps) {
       args.add("-map", map);