GSoC 2026 Proposal — Lossless JPEG Blur & Edit Screen UI Revamp (Wikimedia Commons Android App)

Profile Information

Synopsis

Project Title

Lossless JPEG Blur and Edit Screen UI Revamp for the Wikimedia Commons Android App

Summary

Wikimedia Commons hosts freely usable media files. When contributors upload photographs, they often need to blur sensitive content — faces of bystanders, vehicle license plates — to comply with privacy expectations before images become globally accessible. Currently, any blur operation would require full JPEG re-encoding, which degrades image quality across the entire photograph, even regions that were not edited. This is unacceptable for an archival-quality media repository.

This project proposes lossless JPEG blur: JPEG images are encoded as 8×8 pixel blocks of DCT (Discrete Cosine Transform) coefficients. By selectively attenuating the high-frequency coefficients in only the blocks the user wants to blur — while leaving every other block byte-identical to the original — we achieve privacy-preserving edits with zero quality loss to untouched regions.

Building on my already-implemented lossless JPEG crop and rotation , this project will:

1. Implement lossless JPEG blur via direct DCT coefficient manipulation using the existing LLJTran library. LLJTran already decodes and stores all DCT coefficients internally in a 5-dimensional sparse array (dct_coefs[mcu_row][mcu_col][block_within_mcu][2][num_nonzero_coefficients]). By accessing this private field via reflection and truncating the high-frequency entries for targeted blocks, we achieve true lossless blur with zero new native dependencies.
2. Add automatic face and license plate detection using Google ML Kit (on-device), mapping detected bounding boxes to JPEG MCU block boundaries so regions can be blurred in one tap.
3. Fully revamp the Edit screen UI using Jetpack Compose with Material3, establishing it as a reference architecture for the app's ongoing migration from XML views to Compose.

• Phabricator: T415446
• GitHub Issue: #1192
• Project Size: Large (350 hours / 12 weeks, ~29 hours/week)

Possible Mentor(s)

Nicolas Raoul, Ritika Pahva

Have you contacted your mentors already?

They are already familiar with my work on the lossless crop and rotate features, and we talk in github

Deliverables

Technical Architecture Overview

Before the week-by-week breakdown, here is how the three deliverables are architecturally connected:

1. Lossless JPEG Blur Engine (LLJTran DCT reflection)

The app already depends on com.github.juanitobananas:AndroidMediaUtil (v1.0-1) which provides LLJTran for lossless crop and rotate. Crucially, LLJTran fully decodes and stores all DCT coefficients in memory after read(READ_ALL):

// Inside LLJTran (private field)
private int[][][][][] dct_coefs;
// dct_coefs[mcu_row][mcu_col][block_within_mcu][2][num_nonzero_coefficients]
// [..][..][..][0][k] = coefficient value
// [..][..][..][1][k] = zigzag position (0 = DC, 1–63 = AC)

The field is private with no public getter, but the library version is pinned and the internal structure is stable. Using Java reflection to access dct_coefs, we can manipulate individual blocks without any new native dependencies — the same library that already handles crop and rotate also powers blur.

The blur algorithm for each targeted 8×8 block:

1. Access the sparse coefficient array via reflection
2. Preserve the DC coefficient (zigzag position 0) and optionally the lowest few AC coefficients
3. Truncate or attenuate remaining high-frequency coefficients by a strength-dependent factor
4. Save with transform(NONE) — LLJTran re-encodes the modified coefficients, leaving untouched blocks byte-identical

Kotlin interface (extends existing TransformImage):

interface TransformImage {
    fun rotateImage(imageFile: File, degree: Int, savePath: File): File?
    fun cropImage(imageFile: File, left: Int, top: Int, width: Int, height: Int, savePath: File): File?
    fun blurRegions(imageFile: File, regions: List<BlurRegion>, strength: Float, savePath: File): File?
}

data class BlurRegion(val left: Int, val top: Int, val width: Int, val height: Int)

2. Auto-Detection (Google ML Kit, on-device)

• ML Kit Face Detection for faces (reliable, ~1.5 MB model)
• ML Kit Text Recognition v2 for license plates (filtered by aspect ratio + alphanumeric heuristics)
• Both run on a downsampled Bitmap; bounding boxes scale linearly to full resolution then map to MCU coordinates: mcuX = pixelX / mcuWidth

3. Compose UI Revamp

The Edit screen will be rewritten using ComponentActivity + setContent{} (following the SingleWebViewActivity pattern already in the codebase). State management via ViewModel + StateFlow + collectAsStateWithLifecycle(). The crop overlay (CropOverlayView, currently 398 lines of custom Canvas View) will be reimplemented as Compose Canvas with detectDragGestures. DI integration via CommonsApplicationComponent.inject().

sealed interface EditScreenState {
    data object Loading : EditScreenState
    data class Ready(
        val imagePath: String,
        val currentRotation: Int,
        val activeToolMode: ToolMode,
        val blurRegions: List<BlurRegion>,
        val detectedFaces: List<DetectedRegion>,
        val detectedPlates: List<DetectedRegion>,
    ) : EditScreenState
    data class Saving(val progress: Float) : EditScreenState
    data class Error(val message: String) : EditScreenState
}
enum class ToolMode { NONE, ROTATE, CROP, BLUR }

Week-by-Week Timeline

Why a large project (350 hours / 12 weeks,): The full scope — lossless blur engine, ML Kit auto-detection, and a complete Compose UI rewrite — warrants a large project. At ~29 hours/week, there is enough bandwidth for thorough testing, mentor-driven code review cycles, and a robust Compose migration that can serve as a reference architecture for the rest of the app. The hardest problems — MCU alignment, coordinate mapping, EXIF preservation, the LLJTran crop bug workaround — are already solved in the crop implementation, which de-risks the blur engine work and lets us invest more time in detection quality and UI polish.

Community Bonding Period (before coding starts)

Phase 1: Lossless JPEG Blur Engine + UI (Weeks 1–4)

⭐ Midterm Evaluation

Deliverable: Functional lossless JPEG blur integrated into the edit screen. Users can draw rectangular regions and blur them without quality loss to the rest of the image. All blur tests passing. Non-JPEG fallback working. Byte-identity of untouched regions verified.

Phase 2: Auto-Detection + Compose UI Migration (Weeks 5–10)

Phase 3: Hardening + Final Delivery (Weeks 11–12)

Participation

• Communication: Weekly progress updates on Phabricator (T415446) and the constant communication over email and github, Will post brief updates after each milestone and longer write-ups at midterm and final evaluation.
• Source code: All code will be developed on feature branches in the commons-app/apps-android-commons GitHub repository. PRs will be submitted for review at logical milestones (end of each phase, at minimum).
• Blog: Will write 1-2 blog posts during the program documenting the lossless blur technique and Compose migration approach, to benefit the broader open-source community.

About Me

Education

Bachelor's degree in Computer Science, completed in 2024.

How did you hear about this program?

I first heard about Google Summer of Code while I was in college.

Other time commitments

I have a full-time job during the coding period. The 350-hour large project is manageable alongside my work schedule.

Applying to both GSoC and Outreachy?

No.

What does making this project happen mean to you?

This project is deeply personal to me. I first developed the lossless rotate feature a long time ago while I was still a student, and recently I came back to implement the crop feature as well. This GSoC period would be like wrapping it all up — adding the blur feature and then overhauling the edit screen UI/UX so the entire experience is much better for users. It gives me real satisfaction knowing that my contributions will be used by people around the world to support the Wikimedia Commons initiative. Beyond that, there is a deep technical satisfaction in completing what has been a multi-year journey through JPEG internals, lossless image processing, and now modern Android architecture — seeing this project through from start to finish.

Past Experience

• 1. Contributions to Wikimedia Commons Android App
• Lossless JPEG Crop and Rotate — Implemented the crop and rotate features, apart from other contributions:
  • #6645 — Feat: Add crop functionality to image editing with overlay support (merged Mar 2026)
  • #5252 — Lossless Transformations (Rotate feature) (merged Oct 2023)
  • #5430 — Fixed bitmap too large issue (merged Jan 2024)
  • #5188 — Enable support toolbar for ProfileActivity and added unit tests (merged Apr 2023)
  • #5185 — Fixed misleading warning title for duplicate file name (merged Apr 2023)

• 1. Other Open Source Experience
• GSoC 2022 — Developing Support For Android Auto (Organic Maps, mentored by Roman Tsisyk): Added Android Auto and Android OS support to the Organic Maps navigation app, implementing shared code paths so the app works on both Android Automotive OS and Android Auto. (Blog write-up)