Sample projects

sample/
├── app/
│   ├── src/main/java/photos/eyeq/sample/
│   │   ├── App.kt                        # Application class with SDK init
│   │   ├── core/                         # Base classes
│   │   │   ├── BaseFragment.kt
│   │   │   ├── BaseRepository.kt
│   │   │   └── BaseViewModel.kt
│   │   ├── di/
│   │   │   └── AppModule.kt              # Hilt dependency injection
│   │   ├── media/
│   │   │   └── Media.kt                  # Media data models
│   │   ├── ui/
│   │   │   ├── home/
│   │   │   │   ├── HomeFragment.kt       # Gallery grid view
│   │   │   │   ├── HomeViewModel.kt
│   │   │   │   └── MediaAdapter.kt       # RecyclerView adapter
│   │   │   ├── main/
│   │   │   │   └── MainActivity.kt       # Navigation host
│   │   │   └── preview/
│   │   │       ├── PreviewFragment.kt    # Image preview with slider
│   │   │       └── PreviewViewModel.kt   # Processing logic
│   │   └── utils/
│   │       ├── StorageUtil.kt            # Save processed images
│   │       └── ktx/                      # Kotlin extensions
│   └── build.gradle
├── build.gradle
└── settings.gradle.kts

@Module
@InstallIn(SingletonComponent::class)
class AppModule {

    @Provides
    @Singleton
    fun provideDynamicProcessor(
        @ApplicationContext context: Context
    ): DynamicProcessor {
        val apiKey = "your_api_key"
        val cert = "your_certificate"
        
        val dynamicProcessor = DynamicProcessor(context)
        dynamicProcessor.setLicence(apiKey = apiKey, cert = cert)
        return dynamicProcessor
    }
}

@HiltAndroidApp
class App : Application() {

    @Inject
    lateinit var dynamic: DynamicProcessor

    override fun onCreate() {
        super.onCreate()
        dynamic.init(useGpu = true)
    }
}

override fun setupViews() = with(binding) {
    loadBitmap()
    
    // Slider for real-time strength adjustment
    dynamicStrength.value = DEFAULT_STRENGTH
    dynamicStrength.addOnChangeListener { _, value, _ ->
        preview.setStrength(value / 100f)
        preview.requestRender()
    }
}

private fun loadBitmap() = lifecycleScope.launch {
    binding.loading.isVisible = true
    
    val bitmap = withContext(ioDispatcher) {
        fetchBitmap(safeArgs.imgUri)
    }
    
    binding.preview.setBitmap(bitmap)
    viewModel.setImage(bitmap, DEFAULT_STRENGTH / 100f)
}

// Fast preview processing - returns DynamicOutputs for DynamicView
fun setImage(bitmap: Bitmap, strength: Float) = viewModelScope.launch(ioDispatcher) {
    val result = dynamicProcessor.processImagePreview(bitmap, strength = strength)
    _dynamicResult.postValue(result)
}

// Full resolution processing - returns Bitmap for saving
fun saveImage(bitmap: Bitmap, strength: Float) = viewModelScope.launch(ioDispatcher) {
    val fullSizeImage = dynamicProcessor.processImage(bitmap = bitmap, strength = strength)
    storageUtil.saveImage(fullSizeImage, folderName = "Dynamic")
    _saveResult.postValue(Unit)
}

android {
    // Prevent compression of model files
    androidResources {
        noCompress("pnn", "pnne")
    }
}

dependencies {
    // SDK AAR file
    implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
    
    // TensorFlow Lite for ML inference
    implementation "org.tensorflow:tensorflow-lite:2.8.0"
    implementation "org.tensorflow:tensorflow-lite-gpu:2.8.0"
    
    // Hilt for dependency injection
    implementation "com.google.dagger:hilt-android:2.40.5"
    kapt "com.google.dagger:hilt-compiler:2.40.5"
    
    // Architecture components
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.4.1"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.1"
    implementation "androidx.navigation:navigation-fragment-ktx:2.4.1"
}

Sample/
├── DynamicDemo/
│   ├── AppDelegate.swift             # App lifecycle
│   ├── SceneDelegate.swift           # Scene lifecycle
│   ├── ViewController.swift          # Main camera view controller
│   ├── PreviewView.swift             # AVCaptureVideoPreviewLayer wrapper
│   ├── RuntimeError.swift            # Error handling
│   ├── Info.plist                    # Camera usage description
│   ├── Base.lproj/
│   │   ├── Main.storyboard
│   │   └── LaunchScreen.storyboard
│   ├── Assets.xcassets/              # Images and icons
│   └── DynamicFramework.xcframework/ # Embedded SDK framework
└── DynamicDemo.xcodeproj

struct Constants {
    static let certificate = #"your_certificate"#
    static let apiKey = "your_api_key"
}

class ViewController: UIViewController {
    
    private let pfcDynamic = PFCDynamic(
        apiKey: Constants.apiKey, 
        certificate: Constants.certificate
    )
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Configure deflickering for video
        pfcDynamic.setParams(
            deflickerCurve: 0.08, 
            deflickerImage: 0.9, 
            skip: 0
        )
        
        setupViews()
    }
}

extension ViewController: AVCaptureVideoDataOutputSampleBufferDelegate {
    
    func captureOutput(
        _ output: AVCaptureOutput,
        didOutput sampleBuffer: CMSampleBuffer,
        from connection: AVCaptureConnection
    ) {
        guard let imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer),
              let sourceCgImage = cgImage(from: imageBuffer) else { return }
        
        do {
            let filteredCgImage = try pfcDynamic.processImage(
                sourceCgImage,
                strength: dynamicStrength
            )
            
            // Handle front camera mirroring
            let isMirrored = videoDeviceInput?.device.position == .front
            let orientation: UIImage.Orientation = isMirrored ? .upMirrored : .up
            
            let filteredImage = UIImage(
                cgImage: filteredCgImage,
                scale: 1,
                orientation: orientation
            )
            
            DispatchQueue.main.async {
                self.filteredFrameView.image = filteredImage
            }
        } catch {
            debugPrint(error)
        }
    }
}

@objc func rotateButtonTapped(_ sender: AnyObject) {
    sessionQueue.async {
        // ... camera switching logic ...
        
        // Reset deflicker when switching cameras
        self.pfcDynamic.resetDeflicker()
        
        self.session.commitConfiguration()
    }
}

class PreviewView: UIView {
    
    var videoPreviewLayer: AVCaptureVideoPreviewLayer {
        guard let layer = layer as? AVCaptureVideoPreviewLayer else {
            fatalError("Expected AVCaptureVideoPreviewLayer type for layer.")
        }
        return layer
    }
    
    var session: AVCaptureSession? {
        get { return videoPreviewLayer.session }
        set { videoPreviewLayer.session = newValue }
    }
    
    override class var layerClass: AnyClass {
        return AVCaptureVideoPreviewLayer.self
    }
}

func cgImage(from imageBuffer: CVImageBuffer) -> CGImage? {
    let ciImage = CIImage(cvImageBuffer: imageBuffer)
    let ciContext = CIContext(options: [CIContextOption.useSoftwareRenderer: false])
    
    let colorSpace = CGColorSpaceCreateDeviceRGB()
    let width = Int(ciImage.extent.size.width)
    let height = Int(ciImage.extent.size.height)
    
    // Allocate memory and render CIImage to bitmap
    let bytesPerRow = width * 4
    let contextMemoryCapacity = width * height * 4 * 8
    let dataPointer = UnsafeMutableRawPointer.allocate(
        byteCount: contextMemoryCapacity,
        alignment: MemoryLayout<UInt8>.alignment
    )
    
    ciContext.render(
        ciImage,
        toBitmap: dataPointer,
        rowBytes: bytesPerRow,
        bounds: ciImage.extent,
        format: .RGBA8,
        colorSpace: colorSpace
    )
    
    // Create CGImage from bitmap data
    // ... provider and bitmapInfo setup ...
    
    return CGImage(
        width: width,
        height: height,
        bitsPerComponent: 8,
        bitsPerPixel: 32,
        bytesPerRow: bytesPerRow,
        space: colorSpace,
        bitmapInfo: bitmapInfo,
        provider: provider,
        decode: nil,
        shouldInterpolate: false,
        intent: .defaultIntent
    )
}