Add Image Transcode And New Format Support

* Add image-to-image conversion support for PNG, JPG, WEBP, BMP, TIFF, HEIC, and HEIF
* Register new conversion routes in the conversion hub
* Extend probing logic with stricter format detection for WEBP, BMP, TIFF, HEIC, HEIF, and AVIF
* Improve MIME validation, stream signature checks, and metadata tag parsing
* Introduce codec wrapper classes for MP3, OGG, WAV, MP4, and image codecs
* Centralize decode entry points to standardize media handling
* Refactor internal codec initialization flow for better extensibility
* Expand test coverage for new image formats and validation paths
* Update documentation to reflect new features and current audio conversion limitations

Author: TamKungZ

README.md

@@ -15,10 +15,15 @@ CodecMedia is a Java library for media probing, validation, metadata sidecar per
   - WAV (RIFF/WAVE)
   - PNG
   - JPEG
+  - WebP
+  - BMP
+  - TIFF
+  - HEIC/HEIF/AVIF (basic BMFF parsing)
   - MP4 (basic ISO BMFF parsing)
-- Validation with size limits and strict parser checks for MP3/OGG/WAV/PNG/JPEG/MP4
+- Validation with size limits and strict parser checks for MP3/OGG/WAV/PNG/JPEG/WebP/BMP/TIFF/HEIC/HEIF/AVIF/MP4
 - Metadata read/write with sidecar persistence (`.codecmedia.properties`)
-- In-Java extraction and conversion file operations (no external transcoder required for current stub flows)
+- In-Java extraction and conversion file operations
+- Image-to-image conversion in Java for: `png`, `jpg`/`jpeg`, `webp`, `bmp`, `tif`/`tiff`, `heic`/`heif`
 - Playback API with dry-run support and optional desktop-open backend
 - Conversion hub routing with explicit unsupported routes and a stub `wav <-> pcm` path
 
@@ -37,7 +42,9 @@ CodecMedia is a Java library for media probing, validation, metadata sidecar per
 
 - Current probing focuses on **technical media info** (mime/type/streams/basic tags).
 - `readMetadata` currently uses sidecar metadata persistence; it is **not** a full embedded tag extractor (for example ID3 album art/APIC).
-- Current audio-to-audio conversion is mostly unsupported except a temporary stub copy route for `wav <-> pcm`.
+- Audio-to-audio conversion is not implemented yet for real transcode cases (for example `mp3 -> ogg`).
+- The only temporary audio conversion path is a stub `wav <-> pcm` route.
+- For OpenAL workflows that require OGG from MP3 input, use an external transcoder first (for example ffmpeg), then play the produced OGG.
 
 ## Requirements
 
@@ -82,3 +89,7 @@ mvn test
 ## License
 
 This project is licensed under the Apache License 2.0.
+
+---
+
+*by TamKungZ_*

icon.png

@@ -7,7 +7,7 @@
 
   <groupId>me.tamkungz.codecmedia</groupId>
   <artifactId>codecmedia</artifactId>
-  <version>1.0.0</version>
+  <version>1.0.1</version>
   <packaging>jar</packaging>
 
   <name>CodecMedia</name>

pom.xml

@@ -16,19 +16,31 @@
 
 import me.tamkungz.codecmedia.CodecMediaEngine;
 import me.tamkungz.codecmedia.CodecMediaException;
+import me.tamkungz.codecmedia.internal.audio.mp3.Mp3Codec;
 import me.tamkungz.codecmedia.internal.audio.mp3.Mp3Parser;
 import me.tamkungz.codecmedia.internal.audio.mp3.Mp3ProbeInfo;
+import me.tamkungz.codecmedia.internal.audio.ogg.OggCodec;
 import me.tamkungz.codecmedia.internal.audio.ogg.OggParser;
 import me.tamkungz.codecmedia.internal.audio.ogg.OggProbeInfo;
+import me.tamkungz.codecmedia.internal.audio.wav.WavCodec;
 import me.tamkungz.codecmedia.internal.audio.wav.WavParser;
 import me.tamkungz.codecmedia.internal.audio.wav.WavProbeInfo;
 import me.tamkungz.codecmedia.internal.convert.ConversionHub;
 import me.tamkungz.codecmedia.internal.convert.ConversionRequest;
 import me.tamkungz.codecmedia.internal.convert.DefaultConversionHub;
+import me.tamkungz.codecmedia.internal.image.bmp.BmpParser;
+import me.tamkungz.codecmedia.internal.image.bmp.BmpProbeInfo;
+import me.tamkungz.codecmedia.internal.image.heif.HeifParser;
+import me.tamkungz.codecmedia.internal.image.heif.HeifProbeInfo;
 import me.tamkungz.codecmedia.internal.image.jpeg.JpegParser;
 import me.tamkungz.codecmedia.internal.image.jpeg.JpegProbeInfo;
 import me.tamkungz.codecmedia.internal.image.png.PngParser;
 import me.tamkungz.codecmedia.internal.image.png.PngProbeInfo;
+import me.tamkungz.codecmedia.internal.image.tiff.TiffParser;
+import me.tamkungz.codecmedia.internal.image.tiff.TiffProbeInfo;
+import me.tamkungz.codecmedia.internal.image.webp.WebpParser;
+import me.tamkungz.codecmedia.internal.image.webp.WebpProbeInfo;
+import me.tamkungz.codecmedia.internal.video.mp4.Mp4Codec;
 import me.tamkungz.codecmedia.internal.video.mp4.Mp4Parser;
 import me.tamkungz.codecmedia.internal.video.mp4.Mp4ProbeInfo;
 import me.tamkungz.codecmedia.model.ConversionResult;
@@ -70,7 +82,7 @@ public ProbeResult probe(Path input) throws CodecMediaException {
             if ("mp3".equals(extension) || isLikelyMp3(bytes)) {
                 if (bytes.length >= 4) {
                     try {
-                        Mp3ProbeInfo info = Mp3Parser.parse(bytes);
+                        Mp3ProbeInfo info = Mp3Codec.decode(bytes, input);
                         return new ProbeResult(
                                 input,
                                 "audio/mpeg",
@@ -91,7 +103,7 @@ public ProbeResult probe(Path input) throws CodecMediaException {
             }
 
             if ("ogg".equals(extension) || isLikelyOgg(bytes)) {
-                OggProbeInfo info = OggParser.parse(bytes);
+                OggProbeInfo info = OggCodec.decode(bytes, input);
                 return new ProbeResult(
                         input,
                         "audio/ogg",
@@ -108,7 +120,7 @@ public ProbeResult probe(Path input) throws CodecMediaException {
 
             if ("wav".equals(extension) || WavParser.isLikelyWav(bytes)) {
                 try {
-                    WavProbeInfo info = WavParser.parse(bytes);
+                    WavProbeInfo info = WavCodec.decode(bytes, input);
                     return new ProbeResult(
                             input,
                             "audio/wav",
@@ -169,12 +181,118 @@ public ProbeResult probe(Path input) throws CodecMediaException {
                 return new ProbeResult(input, "image/jpeg", outputExt, MediaType.IMAGE, null, List.of(), Map.of("sizeBytes", String.valueOf(size)));
             }
 
+            if ("webp".equals(extension) || WebpParser.isLikelyWebp(bytes)) {
+                try {
+                    WebpProbeInfo info = WebpParser.parse(bytes);
+                    java.util.LinkedHashMap<String, String> tags = new java.util.LinkedHashMap<>();
+                    tags.put("sizeBytes", String.valueOf(size));
+                    if (info.bitDepth() != null) {
+                        tags.put("bitDepth", String.valueOf(info.bitDepth()));
+                    }
+                    return new ProbeResult(
+                            input,
+                            "image/webp",
+                            "webp",
+                            MediaType.IMAGE,
+                            null,
+                            List.of(new StreamInfo(0, StreamKind.VIDEO, "webp", null, null, null, info.width(), info.height(), null)),
+                            tags
+                    );
+                } catch (CodecMediaException ignored) {
+                    // Fall back to extension-only probe for malformed/partial files.
+                }
+                return new ProbeResult(input, "image/webp", "webp", MediaType.IMAGE, null, List.of(), Map.of("sizeBytes", String.valueOf(size)));
+            }
+
+            if ("bmp".equals(extension) || BmpParser.isLikelyBmp(bytes)) {
+                try {
+                    BmpProbeInfo info = BmpParser.parse(bytes);
+                    return new ProbeResult(
+                            input,
+                            "image/bmp",
+                            "bmp",
+                            MediaType.IMAGE,
+                            null,
+                            List.of(new StreamInfo(0, StreamKind.VIDEO, "bmp", null, null, null, info.width(), info.height(), null)),
+                            Map.of(
+                                    "sizeBytes", String.valueOf(size),
+                                    "bitsPerPixel", String.valueOf(info.bitsPerPixel())
+                            )
+                    );
+                } catch (CodecMediaException ignored) {
+                    // Fall back to extension-only probe for malformed/partial files.
+                }
+                return new ProbeResult(input, "image/bmp", "bmp", MediaType.IMAGE, null, List.of(), Map.of("sizeBytes", String.valueOf(size)));
+            }
+
+            if ("tif".equals(extension) || "tiff".equals(extension) || TiffParser.isLikelyTiff(bytes)) {
+                String outputExt = "tiff".equals(extension) ? "tiff" : "tif";
+                try {
+                    TiffProbeInfo info = TiffParser.parse(bytes);
+                    java.util.LinkedHashMap<String, String> tags = new java.util.LinkedHashMap<>();
+                    tags.put("sizeBytes", String.valueOf(size));
+                    if (info.bitDepth() != null) {
+                        tags.put("bitDepth", String.valueOf(info.bitDepth()));
+                    }
+                    return new ProbeResult(
+                            input,
+                            "image/tiff",
+                            outputExt,
+                            MediaType.IMAGE,
+                            null,
+                            List.of(new StreamInfo(0, StreamKind.VIDEO, "tiff", null, null, null, info.width(), info.height(), null)),
+                            tags
+                    );
+                } catch (CodecMediaException ignored) {
+                    // Fall back to extension-only probe for malformed/partial files.
+                }
+                return new ProbeResult(input, "image/tiff", outputExt, MediaType.IMAGE, null, List.of(), Map.of("sizeBytes", String.valueOf(size)));
+            }
+
+            if ("heic".equals(extension) || "heif".equals(extension) || "avif".equals(extension) || HeifParser.isLikelyHeif(bytes)) {
+                String outputExt = "heif".equals(extension) ? "heif" : "heic";
+                if ("avif".equals(extension)) {
+                    outputExt = "avif";
+                }
+                String mimeType = "image/" + outputExt;
+                try {
+                    HeifProbeInfo info = HeifParser.parse(bytes);
+                    String majorBrand = info.majorBrand();
+                    if ("avif".equals(majorBrand) || "avis".equals(majorBrand)) {
+                        outputExt = "avif";
+                        mimeType = "image/avif";
+                    }
+                    java.util.List<StreamInfo> streams = List.of();
+                    if (info.width() != null && info.height() != null) {
+                        streams = List.of(new StreamInfo(0, StreamKind.VIDEO, outputExt, null, null, null, info.width(), info.height(), null));
+                    }
+                    java.util.LinkedHashMap<String, String> tags = new java.util.LinkedHashMap<>();
+                    tags.put("sizeBytes", String.valueOf(size));
+                    tags.put("majorBrand", majorBrand);
+                    if (info.bitDepth() != null) {
+                        tags.put("bitDepth", String.valueOf(info.bitDepth()));
+                    }
+                    return new ProbeResult(
+                            input,
+                            mimeType,
+                            outputExt,
+                            MediaType.IMAGE,
+                            null,
+                            streams,
+                            tags
+                    );
+                } catch (CodecMediaException ignored) {
+                    // Fall back to extension-only probe for malformed/partial files.
+                }
+                return new ProbeResult(input, mimeType, outputExt, MediaType.IMAGE, null, List.of(), Map.of("sizeBytes", String.valueOf(size)));
+            }
+
             if ("mp4".equals(extension) || "m4a".equals(extension) || Mp4Parser.isLikelyMp4(bytes)) {
                 String outputExt = "m4a".equals(extension) ? "m4a" : "mp4";
                 String mimeType = "m4a".equals(outputExt) ? "audio/mp4" : "video/mp4";
                 MediaType mediaType = "m4a".equals(outputExt) ? MediaType.AUDIO : MediaType.VIDEO;
                 try {
-                    Mp4ProbeInfo info = Mp4Parser.parse(bytes);
+                    Mp4ProbeInfo info = Mp4Codec.decode(bytes, input);
                     java.util.LinkedHashMap<String, String> tags = new java.util.LinkedHashMap<>();
                     tags.put("sizeBytes", String.valueOf(size));
                     if (info.majorBrand() != null && !info.majorBrand().isBlank()) {
@@ -211,12 +329,18 @@ public ProbeResult probe(Path input) throws CodecMediaException {
                 case "wav" -> "audio/wav";
                 case "png" -> "image/png";
                 case "jpg", "jpeg" -> "image/jpeg";
+                case "webp" -> "image/webp";
+                case "bmp" -> "image/bmp";
+                case "tif", "tiff" -> "image/tiff";
+                case "heic" -> "image/heic";
+                case "heif" -> "image/heif";
+                case "avif" -> "image/avif";
                 default -> "application/octet-stream";
             };
             MediaType mediaType = switch (extension) {
                 case "mp4" -> MediaType.VIDEO;
                 case "m4a", "mp3", "ogg", "wav" -> MediaType.AUDIO;
-                case "png", "jpg", "jpeg" -> MediaType.IMAGE;
+                case "png", "jpg", "jpeg", "webp", "bmp", "tif", "tiff", "heic", "heif", "avif" -> MediaType.IMAGE;
                 default -> MediaType.UNKNOWN;
             };
 
@@ -441,6 +565,30 @@ public ValidationResult validate(Path input, ValidationOptions options) {
                     } catch (CodecMediaException e) {
                         return new ValidationResult(false, List.of(), List.of("Strict validation failed for " + extension + ": " + e.getMessage()));
                     }
+                } else if ("webp".equals(extension)) {
+                    try {
+                        WebpParser.parse(bytes);
+                    } catch (CodecMediaException e) {
+                        return new ValidationResult(false, List.of(), List.of("Strict validation failed for webp: " + e.getMessage()));
+                    }
+                } else if ("bmp".equals(extension)) {
+                    try {
+                        BmpParser.parse(bytes);
+                    } catch (CodecMediaException e) {
+                        return new ValidationResult(false, List.of(), List.of("Strict validation failed for bmp: " + e.getMessage()));
+                    }
+                } else if ("tif".equals(extension) || "tiff".equals(extension)) {
+                    try {
+                        TiffParser.parse(bytes);
+                    } catch (CodecMediaException e) {
+                        return new ValidationResult(false, List.of(), List.of("Strict validation failed for tif/tiff: " + e.getMessage()));
+                    }
+                } else if ("heic".equals(extension) || "heif".equals(extension) || "avif".equals(extension)) {
+                    try {
+                        HeifParser.parse(bytes);
+                    } catch (CodecMediaException e) {
+                        return new ValidationResult(false, List.of(), List.of("Strict validation failed for heic/heif/avif: " + e.getMessage()));
+                    }
                 }
             }
 
@@ -504,7 +652,7 @@ private static MediaType mediaTypeByExtension(String extension) {
         return switch (normalizeExtension(extension)) {
             case "mp3", "ogg", "wav", "pcm", "m4a", "aac", "flac" -> MediaType.AUDIO;
             case "mp4", "mkv", "mov", "avi", "webm" -> MediaType.VIDEO;
-            case "png", "jpg", "jpeg", "gif", "bmp", "webp" -> MediaType.IMAGE;
+            case "png", "jpg", "jpeg", "gif", "bmp", "webp", "tif", "tiff", "heic", "heif", "avif" -> MediaType.IMAGE;
             default -> MediaType.UNKNOWN;
         };
     }

src/main/java/me/tamkungz/codecmedia/internal/StubCodecMediaEngine.java

@@ -0,0 +1,46 @@
+package me.tamkungz.codecmedia.internal.audio.mp3;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import me.tamkungz.codecmedia.CodecMediaException;
+
+public final class Mp3Codec {
+
+    private Mp3Codec() {
+    }
+
+    public static Mp3ProbeInfo decode(Path input) throws CodecMediaException {
+        try {
+            byte[] bytes = Files.readAllBytes(input);
+            return decode(bytes, input);
+        } catch (IOException e) {
+            throw new CodecMediaException("Failed to decode MP3: " + input, e);
+        }
+    }
+
+    public static Mp3ProbeInfo decode(byte[] bytes, Path sourceRef) throws CodecMediaException {
+        Mp3ProbeInfo info = Mp3Parser.parse(bytes);
+        validateDecodedProbe(info, sourceRef);
+        return info;
+    }
+
+    public static void encode(byte[] encodedMp3Data, Path output) throws CodecMediaException {
+        if (encodedMp3Data == null || encodedMp3Data.length == 0) {
+            throw new CodecMediaException("MP3 encoded data is empty");
+        }
+        try {
+            Files.write(output, encodedMp3Data);
+        } catch (IOException e) {
+            throw new CodecMediaException("Failed to encode MP3: " + output, e);
+        }
+    }
+
+    private static void validateDecodedProbe(Mp3ProbeInfo info, Path input) throws CodecMediaException {
+        if (info.sampleRate() <= 0 || info.channels() <= 0) {
+            throw new CodecMediaException("Decoded MP3 has invalid stream values: " + input);
+        }
+    }
+}
+

src/main/java/me/tamkungz/codecmedia/internal/audio/mp3/Mp3Codec.java

@@ -0,0 +1,46 @@
+package me.tamkungz.codecmedia.internal.audio.ogg;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import me.tamkungz.codecmedia.CodecMediaException;
+
+public final class OggCodec {
+
+    private OggCodec() {
+    }
+
+    public static OggProbeInfo decode(Path input) throws CodecMediaException {
+        try {
+            byte[] bytes = Files.readAllBytes(input);
+            return decode(bytes, input);
+        } catch (IOException e) {
+            throw new CodecMediaException("Failed to decode OGG: " + input, e);
+        }
+    }
+
+    public static OggProbeInfo decode(byte[] bytes, Path sourceRef) throws CodecMediaException {
+        OggProbeInfo info = OggParser.parse(bytes);
+        validateDecodedProbe(info, sourceRef);
+        return info;
+    }
+
+    public static void encode(byte[] encodedOggData, Path output) throws CodecMediaException {
+        if (encodedOggData == null || encodedOggData.length == 0) {
+            throw new CodecMediaException("OGG encoded data is empty");
+        }
+        try {
+            Files.write(output, encodedOggData);
+        } catch (IOException e) {
+            throw new CodecMediaException("Failed to encode OGG: " + output, e);
+        }
+    }
+
+    private static void validateDecodedProbe(OggProbeInfo info, Path input) throws CodecMediaException {
+        if (info.sampleRate() <= 0 || info.channels() <= 0) {
+            throw new CodecMediaException("Decoded OGG has invalid stream values: " + input);
+        }
+    }
+}
+