From 52e5e6a73e672c3b9e0b1f6094eea45a4be63c30 Mon Sep 17 00:00:00 2001 From: Davood Rasti Date: Sun, 11 Oct 2026 19:01:42 +0300 Subject: [PATCH] First commit --- .clang-format | 29 + .gitignore | 465 +- LICENSE | 81 +- Makefile | 25 + README.md | 33 +- scenes/Scene001.txt | 30 + scenes/Scene002.txt | 54 + scenes/Scene003.txt | 29 + scenes/Scene004.txt | 23 + scenes/Scene005.txt | 38 + src/3rdparty/stb_collection/stb_image.c | 5456 +++++++++++++++++ src/3rdparty/stb_collection/stb_image_write.h | 1724 ++++++ src/common.h | 75 + src/main.cpp | 810 +++ src/prrpm.cpp | 41 + src/prrpm.h | 322 + src/stb_image_write.cpp | 2 + src/vector3d.h | 167 + 18 files changed, 9342 insertions(+), 62 deletions(-) create mode 100644 .clang-format create mode 100644 Makefile create mode 100644 scenes/Scene001.txt create mode 100644 scenes/Scene002.txt create mode 100644 scenes/Scene003.txt create mode 100644 scenes/Scene004.txt create mode 100644 scenes/Scene005.txt create mode 100644 src/3rdparty/stb_collection/stb_image.c create mode 100644 src/3rdparty/stb_collection/stb_image_write.h create mode 100644 src/common.h create mode 100644 src/main.cpp create mode 100644 src/prrpm.cpp create mode 100644 src/prrpm.h create mode 100644 src/stb_image_write.cpp create mode 100644 src/vector3d.h diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..28098be --- /dev/null +++ b/.clang-format @@ -0,0 +1,29 @@ +# Clang-Format configuration +BasedOnStyle: LLVM + +# Opening braces on new line (Allman style) +BreakBeforeBraces: Allman + +# This ensures: +# - Function opening braces on new line +# - Class opening braces on new line +# - Struct opening braces on new line +# - Control statements (if, while, for) opening braces on new line + +IndentWidth: 4 +TabWidth: 2 +UseTab: Never +ColumnLimit: 100 + +# Namespace indentation +NamespaceIndentation: All + +AlignAfterOpenBracket: true + +# Additional formatting preferences +PointerAlignment: Left +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AllowShortFunctionsOnASingleLine: None +AllowShortIfStatementsOnASingleLine: Never +AllowShortLoopsOnASingleLine: false diff --git a/.gitignore b/.gitignore index 7a042f5..5861218 100644 --- a/.gitignore +++ b/.gitignore @@ -32,57 +32,428 @@ *.out *.app -# ---> C -# Prerequisites -*.d +# ---> CUDA +*.i +*.ii +*.gpu +*.ptx +*.cubin +*.fatbin -# Object files -*.o -*.ko -*.obj -*.elf +# ---> VisualStudio +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore -# Linker output +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +build/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h *.ilk -*.map -*.exp - -# Precompiled Headers -*.gch +*.meta +*.obj +*.iobj *.pch - -# Libraries -*.lib -*.a -*.la -*.lo - -# Shared objects (inc. Windows DLLs) -*.dll -*.so -*.so.* -*.dylib - -# Executables -*.exe -*.out -*.app -*.i*86 -*.x86_64 -*.hex - -# Debug files -*.dSYM/ -*.su -*.idb *.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +# but not Directory.Build.rsp, as it configures directory-level build defaults +!Directory.Build.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc -# Kernel Module Compile Results -*.mod* -*.cmd -.tmp_versions/ -modules.order -Module.symvers -Mkfile.old -dkms.conf +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio 6 auto-generated project file (contains which files were open etc.) +*.vbp + +# Visual Studio 6 workspace and project file (working project files containing files to include in project) +*.dsw +*.dsp + +# Visual Studio 6 technical files +*.ncb +*.aps + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# Visual Studio History (VSHistory) files +.vshistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +*.sln.iml + +# ---> VisualStudioCode +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +!.vscode/*.code-snippets + +# Local History for Visual Studio Code +.history/ + +# Built Visual Studio Code Extensions +*.vsix diff --git a/LICENSE b/LICENSE index b067856..f639d7e 100644 --- a/LICENSE +++ b/LICENSE @@ -1,18 +1,71 @@ -MIT License +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ -Copyright (c) 2026 davoodrasti +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and -associated documentation files (the "Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the -following conditions: +1. Definitions. -The above copyright notice and this permission notice shall be included in all copies or substantial -portions of the Software. +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT -LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO -EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE -USE OR OTHER DEALINGS IN THE SOFTWARE. +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including software source code, documentation, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by Your Authorized Representative. + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + +(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and + +(b) You must cause any modified files to carry prominent notices stating that You changed the files; and + +(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + +(d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if provided alongside the Derivative Works. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + +To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file change history log be included. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..dd0695d --- /dev/null +++ b/Makefile @@ -0,0 +1,25 @@ +CXX ?= c++ +CPPFLAGS += -Isrc +CXXFLAGS ?= -std=c++17 -O2 -Wall -Wextra +DEPFLAGS = -MMD -MP + +TARGET := build/renderer +SOURCES := src/main.cpp src/prrpm.cpp src/stb_image_write.cpp +OBJECTS := $(patsubst src/%.cpp,build/%.o,$(SOURCES)) +DEPFILES := $(OBJECTS:.o=.d) + +.PHONY: all clean + +all: $(TARGET) + +$(TARGET): $(OBJECTS) + $(CXX) $(LDFLAGS) $^ $(LDLIBS) -o $@ + +build/%.o: src/%.cpp + @mkdir -p $(dir $@) + $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(DEPFLAGS) -c $< -o $@ + +-include $(DEPFILES) + +clean: + rm -rf build \ No newline at end of file diff --git a/README.md b/README.md index 78b0b9b..19e3608 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,33 @@ -# ProgressivePhotonMapping-Non-Recursive +# Progressive Photon Mapping: Non-Recursive CPU +A small C++ CPU implementation of photon mapping(non-recursive verion based on original smallppm by T. Hachisuka), developed as a study companion to an earlier CUDA/GPGPU renderer. The project explores how the same photorealistic rendering approach can be implemented and compared on different architectures. + +## Background + +Around 2012, my brother Alireza Rasti and I developed a CUDA-based renderer as part of a student project on using GPGPU to accelerate photorealistic rendering. At the time, CUDA did not support recursive device code in the way ray tracing and photon mapping would naturally use it. We therefore used a non-recursive design in the CUDA version implementation. + +We also built this C++ CPU version using a non-recursive approach. Keeping the CPU implementation close to the CUDA design gave us a more useful basis for comparing the two approaches and studying their trade-offs. + +Note: We have made minor updates to our 2012 implementation to use modern C++. + +## Build and Run + +Build with Make: + +```sh +make +``` + +Run using the included scene file and specify the output image path: + +```sh +./build/renderer ./scenes/Scene004.txt output.bmp +``` + +The renderer requires a scene file and output image path as positional arguments. + +This project currently writes ouput images via stb_image_write. This library can output PNG, TGA, JPEG/JPG, and HDR files when the output writer is configured for those formats. + +## Project Scope + +This repository contains the CPU implementation. It is intended for learning, experimentation, and comparison with the original CUDA project, rather than as a production rendering system. The CUDA version will be available in the repo as well soon. diff --git a/scenes/Scene001.txt b/scenes/Scene001.txt new file mode 100644 index 0000000..c9d014b --- /dev/null +++ b/scenes/Scene001.txt @@ -0,0 +1,30 @@ +imagesize = 1280, 720; +numberOfPhotons = 100000; +numberOfPhotonPass = 1000; +numberOfBounces = 5; + +/==================Scene 01====================== +light = 1; 0.0,0.28125,1.5; 5,5,5; 0.1,0.0,0.1; +s = -0.35,-0.18125,1.85; 0.1; 1.0,1.0,1.0; 1; +s = 0.05,-0.18125,1.22; 0.1; 1.0,1.0,1.0; 2; +s = 0.25,-0.18125,1.7; 0.1; 0.5,1.0,0.5; 0; +s = -0.15,-0.23125,1.7; 0.05; 1.0,1.0,0.0; 0; + +/Front +t = -0.5,0.28125,2.0; 0.5, 0.28125,2.0; -0.5,-0.28125,2.0; 0.75,0.75,0.75; 0; +t = 0.5,0.28125,2.0; 0.5,-0.28125,2.0; -0.5,-0.28125,2.0; 0.75,0.75,0.75; 0; +/Bottom +t = -0.5,-0.28125,2.0; 0.5,-0.28125,2.0; -0.5,-0.28125,1.0; 0.75,0.75,0.75; 0; +t = 0.5,-0.28125,2.0; 0.5,-0.28125,1.0; -0.5,-0.28125,1.0; 0.75,0.75,0.75; 0; +/Right +t = 0.5,0.28125,2.0; 0.5,0.28125,1.0; 0.5,-0.28125,2.0; 0.25,0.25,0.75; 0; +t = 0.5,0.28125,1.0; 0.5,-0.28125,1.0; 0.5,-0.28125,2.0; 0.25,0.25,0.75; 0; +/Left +t = -0.5,-0.28125,2.0; -0.5,0.28125,1.0; -0.5,0.28125,2.0; 0.75,0.25,0.25; 0; +t = -0.5,-0.28125,2.0; -0.5,-0.28125,1.0; -0.5,0.28125,1.0; 0.75,0.25,0.25; 0; +/Top +t = -0.5,0.28125,1.0; 0.5,0.28125,2.0; -0.5,0.28125,2.0; 0.75,0.75,0.75; 0; +t = -0.5,0.28125,1.0; 0.5,0.28125,1.0; 0.5,0.28125,2.0; 0.75,0.75,0.75; 0; +/Back +t = -0.5,-0.28125,1.0; 0.5,0.28125,1.0; -0.5,0.28125,1.0; 0.75,0.75,0.75; 0; +t = -0.5,-0.28125,1.0; 0.5,-0.28125,1.0; 0.5,0.28125,1.0; 0.75,0.75,0.75; 0; \ No newline at end of file diff --git a/scenes/Scene002.txt b/scenes/Scene002.txt new file mode 100644 index 0000000..d5106fb --- /dev/null +++ b/scenes/Scene002.txt @@ -0,0 +1,54 @@ +imagesize = 640, 360; +numberOfPhotons = 1000000; +numberOfPhotonPass = 1000; +numberOfBounces = 5; + +/==================Scene 03====================== +/left lights +light = 0; -0.49,0.27925,1.75; 2,2,2; 0.1,0.0,0.1; +light = 0; -0.49,0.27925,1.5; 2,2,2; 0.1,0.0,0.1; +light = 0; -0.49,0.27925,1.25; 2,2,2; 0.1,0.0,0.1; +/right +light = 0; 0.49,0.27925,1.75; 2,2,2; 0.1,0.0,0.1; +light = 0; 0.49,0.27925,1.5; 2,2,2; 0.1,0.0,0.1; +light = 0; 0.49,0.27925,1.25; 2,2,2; 0.1,0.0,0.1; +/front +light = 0; 0.25,0.27925,1.99; 2,2,2; 0.1,0.0,0.1; +light = 0; 0.0 ,0.27925,1.99; 2,2,2; 0.1,0.0,0.1; +light = 0;-0.25,0.27925,1.99; 2,2,2; 0.1,0.0,0.1; +/back +light = 0; 0.25,0.27925,1.01; 2,2,2; 0.1,0.0,0.1; +light = 0; 0.0 ,0.27925,1.01; 2,2,2; 0.1,0.0,0.1; +light = 0;-0.25,0.27925,1.01; 2,2,2; 0.1,0.0,0.1; +/top +light = 0; 0.25,0.27925,1.25; 2,2,2; 0.1,0.0,0.1; +light = 0; 0.0 ,0.27925,1.25; 2,2,2; 0.1,0.0,0.1; +light = 0;-0.25,0.27925,1.25; 2,2,2; 0.1,0.0,0.1; + +light = 0; 0.25,0.27925,1.5; 2,2,2; 0.1,0.0,0.1; +light = 0; 0.0 ,0.27925,1.5; 2,2,2; 0.1,0.0,0.1; +light = 0;-0.25,0.27925,1.5; 2,2,2; 0.1,0.0,0.1; + +light = 0; 0.25,0.27925,1.75; 2,2,2; 0.1,0.0,0.1; +light = 0; 0.0 ,0.27925,1.75; 2,2,2; 0.1,0.0,0.1; +light = 0;-0.25,0.27925,1.75; 2,2,2; 0.1,0.0,0.1; +s = 0.0,-0.18125,1.5; 0.1; 1.0,1.0,1.0; 2; + +/Front +t = -0.5,0.28125,2.0; 0.5, 0.28125,2.0; -0.5,-0.28125,2.0; 0.75,0.75,0.75; 0; +t = 0.5,0.28125,2.0; 0.5,-0.28125,2.0; -0.5,-0.28125,2.0; 0.75,0.75,0.75; 0; +/Bottom +t = -0.5,-0.28125,2.0; 0.5,-0.28125,2.0; -0.5,-0.28125,1.0; 0.75,0.75,0.75; 0; +t = 0.5,-0.28125,2.0; 0.5,-0.28125,1.0; -0.5,-0.28125,1.0; 0.75,0.75,0.75; 0; +/Right +t = 0.5,0.28125,2.0; 0.5,0.28125,1.0; 0.5,-0.28125,2.0; 0.25,0.25,0.75; 0; +t = 0.5,0.28125,1.0; 0.5,-0.28125,1.0; 0.5,-0.28125,2.0; 0.25,0.25,0.75; 0; +/Left +t = -0.5,-0.28125,2.0; -0.5,0.28125,1.0; -0.5,0.28125,2.0; 0.75,0.25,0.25; 0; +t = -0.5,-0.28125,2.0; -0.5,-0.28125,1.0; -0.5,0.28125,1.0; 0.75,0.25,0.25; 0; +/Top +t = -0.5,0.28125,1.0; 0.5,0.28125,2.0; -0.5,0.28125,2.0; 0.75,0.75,0.75; 0; +t = -0.5,0.28125,1.0; 0.5,0.28125,1.0; 0.5,0.28125,2.0; 0.75,0.75,0.75; 0; +/Back +t = -0.5,-0.28125,1.0; 0.5,0.28125,1.0; -0.5,0.28125,1.0; 0.75,0.75,0.75; 0; +t = -0.5,-0.28125,1.0; 0.5,-0.28125,1.0; 0.5,0.28125,1.0; 0.75,0.75,0.75; 0; \ No newline at end of file diff --git a/scenes/Scene003.txt b/scenes/Scene003.txt new file mode 100644 index 0000000..42d9aa2 --- /dev/null +++ b/scenes/Scene003.txt @@ -0,0 +1,29 @@ +imagesize = 640, 360; +photonCasting = off; +numberOfPhotons = 100000; +numberOfPhotonPass = 1000; +numberOfBounces = 5; + +/==================Scene 02====================== +light = 1; 0.0,0.28125,1.5; 2,2,2; 0.1,0.0,0.1; +s = -0.2,-0.18125,1.5; 0.1; 0.5,1.0,0.5; 1; +s = 0.37,-0.18125,1.27; 0.1; 1.0,1.0,1.0; 2; + +/Front +t = -0.5,0.28125,2.0; 0.5, 0.28125,2.0; -0.5,-0.28125,2.0; 0.75,0.75,0.75; 0; +t = 0.5,0.28125,2.0; 0.5,-0.28125,2.0; -0.5,-0.28125,2.0; 0.75,0.75,0.75; 0; +/Bottom +t = -0.5,-0.28125,2.0; 0.5,-0.28125,2.0; -0.5,-0.28125,1.0; 0.75,0.75,0.75; 0; +t = 0.5,-0.28125,2.0; 0.5,-0.28125,1.0; -0.5,-0.28125,1.0; 0.75,0.75,0.75; 0; +/Right +t = 0.5,0.28125,2.0; 0.5,0.28125,1.0; 0.5,-0.28125,2.0; 0.25,0.25,0.75; 0; +t = 0.5,0.28125,1.0; 0.5,-0.28125,1.0; 0.5,-0.28125,2.0; 0.25,0.25,0.75; 0; +/Left +t = -0.5,-0.28125,2.0; -0.5,0.28125,1.0; -0.5,0.28125,2.0; 0.75,0.25,0.25; 0; +t = -0.5,-0.28125,2.0; -0.5,-0.28125,1.0; -0.5,0.28125,1.0; 0.75,0.25,0.25; 0; +/Top +t = -0.5,0.28125,1.0; 0.5,0.28125,2.0; -0.5,0.28125,2.0; 0.75,0.75,0.75; 0; +t = -0.5,0.28125,1.0; 0.5,0.28125,1.0; 0.5,0.28125,2.0; 0.75,0.75,0.75; 0; +/Back +t = -0.5,-0.28125,1.0; 0.5,0.28125,1.0; -0.5,0.28125,1.0; 0.75,0.75,0.75; 0; +t = -0.5,-0.28125,1.0; 0.5,-0.28125,1.0; 0.5,0.28125,1.0; 0.75,0.75,0.75; 0; \ No newline at end of file diff --git a/scenes/Scene004.txt b/scenes/Scene004.txt new file mode 100644 index 0000000..8c045ad --- /dev/null +++ b/scenes/Scene004.txt @@ -0,0 +1,23 @@ +imagesize 800 800 +numberOfPhotons 100000 +numberOfPhotonPass 100 +numberOfPhotonBounces 3 +light pos 0.4 0.4 1.7 + +s 0.0 -0.1 1.7 0.10 1 0 1 +s 0.0 -0.3 1.7 0.20 1 1 0 +/ +t 0.5 0.5 2.0 -0.5 -0.5 2.0 -0.5 0.5 2.0 1 1 1 +t 0.5 0.5 2.0 0.5 -0.5 2.0 -0.5 -0.5 2.0 1 1 1 +/ +t -0.5 -0.5 2.0 0.5 -0.5 2.0 -0.5 -0.5 1.0 1 1 1 +t 0.5 -0.5 2.0 0.5 -0.5 1.0 -0.5 -0.5 1.0 1 1 1 +/ +t 0.5 0.5 2.0 0.5 0.5 1.0 0.5 -0.5 2.0 0.4745098039215686 0.4392156862745098 0.7529411764705882 +t 0.5 0.5 1.0 0.5 -0.5 1.0 0.5 -0.5 2.0 0.4745098039215686 0.4392156862745098 0.7529411764705882 +/ +t -0.5 -0.5 2.0 -0.5 0.5 1.0 -0.5 0.5 2.0 0.7529411764705882 0.4431372549019608 0.4823529411764706 +t -0.5 -0.5 2.0 -0.5 -0.5 1.0 -0.5 0.5 1.0 0.7529411764705882 0.4431372549019608 0.4823529411764706 +/ +t -0.5 0.5 1.0 0.5 0.5 2.0 -0.5 0.5 2.0 1 1 1 +t -0.5 0.5 1.0 0.5 0.5 1.0 0.5 0.5 2.0 1 1 1 diff --git a/scenes/Scene005.txt b/scenes/Scene005.txt new file mode 100644 index 0000000..991d567 --- /dev/null +++ b/scenes/Scene005.txt @@ -0,0 +1,38 @@ +imagesize = 1280, 720; +numberOfPhotons = 100000; +numberOfPhotonPass = 100; +numberOfBounces = 5; + +/==================Scene 04====================== +light = 0; 0.0,0.1,1.5; 10,10,10; 0.1,0.0,0.1; +light = 0; -1.5,0.3790,3.0; 10,10,10; 0.1,0.0,0.1; +light = 0; 1.5,0.3790,3.0; 10,10,10; 0.1,0.0,0.1; +s = 0.3,-0.18125,1.5; 0.1; 1.0,0.6,0.6; 2; +s = -0.3,-0.18125,1.5; 0.1; 0.7,1.0,0.7; 2; +s = 0.0,-0.18125,1.2; 0.1; 1.0,1.0,0.5; 2; + +s = -0.15,-0.23125,1.25; 0.05; 1.0,1.0,0.1; 0; +s = 0.15,-0.23125,1.25; 0.05; 0.5,1.0,0.5; 0; + +s = -0.45,-0.23125,1.06; 0.05; 1.0,1.0,0.1; 0; +s = 0.45,-0.23125,1.06; 0.05; 0.5,1.0,0.5; 0; + + +/Front +t = -0.5,0.28125,2.0; 0.5, 0.28125,2.0; -0.5,-0.28125,2.0; 0.75,0.75,0.75; 0; +t = 0.5,0.28125,2.0; 0.5,-0.28125,2.0; -0.5,-0.28125,2.0; 0.75,0.75,0.75; 0; +/Bottom +t = -0.5,-0.28125,2.0; 0.5,-0.28125,2.0; -0.5,-0.28125,1.0; 0.75,0.75,0.75; 0; +t = 0.5,-0.28125,2.0; 0.5,-0.28125,1.0; -0.5,-0.28125,1.0; 0.75,0.75,0.75; 0; +/Right +t = 0.5,0.28125,2.0; 0.5,0.28125,1.0; 0.5,-0.28125,2.0; 0.25,0.25,0.75; 0; +t = 0.5,0.28125,1.0; 0.5,-0.28125,1.0; 0.5,-0.28125,2.0; 0.25,0.25,0.75; 0; +/Left +t = -0.5,-0.28125,2.0; -0.5,0.28125,1.0; -0.5,0.28125,2.0; 0.75,0.25,0.25; 0; +t = -0.5,-0.28125,2.0; -0.5,-0.28125,1.0; -0.5,0.28125,1.0; 0.75,0.25,0.25; 0; +/Top +t = -0.5,0.28125,1.0; 0.5,0.28125,2.0; -0.5,0.28125,2.0; 0.75,0.75,0.75; 0; +t = -0.5,0.28125,1.0; 0.5,0.28125,1.0; 0.5,0.28125,2.0; 0.75,0.75,0.75; 0; +/Back +t = -0.5,-0.28125,1.0; 0.5,0.28125,1.0; -0.5,0.28125,1.0; 0.75,0.75,0.75; 0; +t = -0.5,-0.28125,1.0; 0.5,-0.28125,1.0; 0.5,0.28125,1.0; 0.75,0.75,0.75; 0; \ No newline at end of file diff --git a/src/3rdparty/stb_collection/stb_image.c b/src/3rdparty/stb_collection/stb_image.c new file mode 100644 index 0000000..d5358ab --- /dev/null +++ b/src/3rdparty/stb_collection/stb_image.c @@ -0,0 +1,5456 @@ +/* stbi-1.33 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c + when you control the images you're loading + no warranty implied; use at your own risk + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline (no JPEG progressive) + PNG 8-bit only + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD) + + Latest revisions: + 1.33 (2011-07-14) minor fixes suggested by Dave Moore + 1.32 (2011-07-13) info support for all filetypes (SpartanJ) + 1.31 (2011-06-19) a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) added ability to loadSound files via io callbacks (Ben Wenger) + 1.29 (2010-08-16) various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) cast-to-uint8 to fix warnings (Laurent Gomila) + allow trailing 0s at end of image data (Laurent Gomila) + 1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ + + See end of file for full revision history. + + TODO: + stbi_info support for BMP,PSD,HDR,PIC + + + ============================ Contributors ========================= + + Image formats Optimizations & bugfixes + Sean Barrett (jpeg, png, bmp) Fabian "ryg" Giesen + Nicolas Schulz (hdr, psd) + Jonathan Dummer (tga) Bug fixes & warning fixes + Jean-Marc Lienher (gif) Marc LeBlanc + Tom Seddon (pic) Christpher Lloyd + Thatcher Ulrich (psd) Dave Moore + Won Chun + the Horde3D community + Extensions, features Janez Zemva + Jetro Lauha (stbi_info) Jonathan Blow + James "moose2000" Brown (iPhone PNG) Laurent Gomila + Ben "Disch" Wenger (io callbacks) Aruelien Pocheville + Martin "SpartanJ" Golini Ryamond Barbiero + David Woo + + + If your name should be here but isn't, let Sean know. + +*/ + +typedef unsigned int uint; + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// To get a header file for this, either cut and paste the header, +// or initialize stb_image.h, #define STBI_HEADER_FILE_ONLY, and +// then include stb_image.c from it. + +//// begin header file //////////////////////////////////////////////////// +// +// Limitations: +// - no jpeg progressive support +// - non-HDR formats support 8-bit samples only (jpeg, png) +// - no delayed line count (jpeg) -- IJG doesn't support either +// - no 1-bit BMP +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = mWidth, y = mHeight, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data) +// +// Standard parameters: +// int *x -- outputs image mWidth in pixels +// int *y -- outputs image mHeight in pixels +// int *comp -- outputs # of image components in image file +// int req_comp -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise. +// If req_comp is non-zero, *comp has the number of components that _would_ +// have been output otherwise. E.g. if you set req_comp to 4, you will always +// get RGBA output, but you can check *comp to easily see if it's opaque. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *comp will be unchanged. The function stbi_failure_reason() +// can be queried for an extremely brief, end-user unfriendly explanation +// of why the loadSound failed. Define STBI_NO_FAILURE_STRINGS to avoid +// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// =========================================================================== +// +// iPhone PNG support: +// +// By default we convert iphone-formatted PNGs back to RGB; nominally they +// would silently loadSound as BGR, except the existing code should have just +// failed on such iPhone PNGs. But you can disable this conversion by +// by calling stbi_convert_iphone_png_to_rgb(0), in which case +// you will always just get the native iphone "format" through. +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image now supports loading HDR images in general, and currently +// the Radiance .HDR file format, although the support is provided +// generically. You can still loadSound any file through the existing interface; +// if you attempt to loadSound an HDR file, it will be automatically remapped to +// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you loadSound LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). + +#ifndef STBI_NO_STDIO + +#if defined(_MSC_VER) && _MSC_VER >= 0x1400 +#define _CRT_SECURE_NO_WARNINGS // suppress bogus warnings about fopen() +#endif + +#include +#endif + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for req_comp + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +typedef unsigned char stbi_uc; + +#ifdef __cplusplus +extern "C" +{ +#endif + + ////////////////////////////////////////////////////////////////////////////// + // + // PRIMARY API - works on images of any type + // + + // + // loadSound image by filename, open file, or memory buffer + // + + extern stbi_uc* stbi_load_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp, + int req_comp); + +#ifndef STBI_NO_STDIO + extern stbi_uc* stbi_load(char const* filename, int* x, int* y, int* comp, int req_comp); + extern stbi_uc* stbi_load_from_file(FILE* f, int* x, int* y, int* comp, int req_comp); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + + typedef struct + { + int (*read)( + void* user, char* data, + int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip)(void* user, unsigned n); // skip the next 'n' bytes + int (*eof)(void* user); // returns nonzero if we are at end of file/data + } stbi_io_callbacks; + + extern stbi_uc* stbi_load_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, + int* y, int* comp, int req_comp); + +#ifndef STBI_NO_HDR + extern float* stbi_loadf_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp, + int req_comp); + +#ifndef STBI_NO_STDIO + extern float* stbi_loadf(char const* filename, int* x, int* y, int* comp, int req_comp); + extern float* stbi_loadf_from_file(FILE* f, int* x, int* y, int* comp, int req_comp); +#endif + + extern float* stbi_loadf_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, + int* y, int* comp, int req_comp); + + extern void stbi_hdr_to_ldr_gamma(float gamma); + extern void stbi_hdr_to_ldr_scale(float scale); + + extern void stbi_ldr_to_hdr_gamma(float gamma); + extern void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_HDR + + // stbi_is_hdr is always defined + extern int stbi_is_hdr_from_callbacks(stbi_io_callbacks const* clbk, void* user); + extern int stbi_is_hdr_from_memory(stbi_uc const* buffer, int len); +#ifndef STBI_NO_STDIO + extern int stbi_is_hdr(char const* filename); + extern int stbi_is_hdr_from_file(FILE* f); +#endif // STBI_NO_STDIO + + // get a VERY brief reason for failure + // NOT THREADSAFE + extern const char* stbi_failure_reason(void); + + // free the loaded image -- this is just free() + extern void stbi_image_free(void* retval_from_stbi_load); + + // get image dimensions & components without fully decoding + extern int stbi_info_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp); + extern int stbi_info_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, int* y, + int* comp); + +#ifndef STBI_NO_STDIO + extern int stbi_info(char const* filename, int* x, int* y, int* comp); + extern int stbi_info_from_file(FILE* f, int* x, int* y, int* comp); + +#endif + + // for image formats that explicitly notate that they have premultiplied alpha, + // we just return the colors as stored in the file. set this flag to force + // unpremultiplication. results are undefined if the unpremultiply overflow. + extern void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + + // indicate whether we should process iphone images back to canonical format, + // or just pass them through "as-is" + extern void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + + // ZLIB client - used by PNG, available for other purposes + + extern char* stbi_zlib_decode_malloc_guesssize(const char* buffer, int len, int initial_size, + int* outlen); + extern char* stbi_zlib_decode_malloc(const char* buffer, int len, int* outlen); + extern int stbi_zlib_decode_buffer(char* obuffer, int olen, const char* ibuffer, int ilen); + + extern char* stbi_zlib_decode_noheader_malloc(const char* buffer, int len, int* outlen); + extern int stbi_zlib_decode_noheader_buffer(char* obuffer, int olen, const char* ibuffer, + int ilen); + +// define faster low-level operations (typically SIMD support) +#ifdef STBI_SIMD + typedef void (*stbi_idct_8x8)(stbi_uc* out, int out_stride, short data[64], + unsigned short* dequantize); + // compute an integer IDCT on "input" + // input[x] = data[x] * dequantize[x] + // write results to 'out': 64 samples, each run of 8 spaced by 'out_stride' + // CLAMP results to 0..255 + typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc* output, stbi_uc const* y, stbi_uc const* cb, + stbi_uc const* cr, int count, int step); + // compute a conversion from YCbCr to RGB + // 'count' pixels + // write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as + // 4th), order R,G,B y: Y input channel cb: Cb input channel; scale/biased to be 0..255 cr: + // Cr input channel; scale/biased to be 0..255 + + extern void stbi_install_idct(stbi_idct_8x8 func); + extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func); +#endif // STBI_SIMD + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifndef STBI_HEADER_FILE_ONLY + +#ifndef STBI_NO_HDR +#include // ldexp +#include // strcmp, strtok +#endif + +#ifndef STBI_NO_STDIO +#include +#endif +#include +#include +#include +#include + +#ifndef _MSC_VER +#ifdef __cplusplus +#define stbi_inline inline +#else +#define stbi_inline +#endif +#else +#define stbi_inline __forceinline +#endif + +// implementation: +typedef unsigned char uint8; +typedef unsigned short uint16; +typedef signed short int16; +typedef unsigned int uint32; +typedef signed int int32; +// typedef unsigned int uint; + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(uint32) == 4 ? 1 : -1]; + +#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE) +#define STBI_NO_WRITE +#endif + +#define STBI_NOTUSED(v) (void)sizeof(v) + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL +#define stbi_lrot(x, y) _lrotl(x, y) +#else +#define stbi_lrot(x, y) (((x) << (y)) | ((x) >> (32 - (y)))) +#endif + +/////////////////////////////////////////////// +// +// stbi struct and start_xxx functions + +// stbi structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void* io_user_data; + + int read_from_callbacks; + int buflen; + uint8 buffer_start[128]; + + uint8 *img_buffer, *img_buffer_end; + uint8* img_buffer_original; +} stbi; + +static void refill_buffer(stbi* s); + +// initialize a memory-decode context +static void start_mem(stbi* s, uint8 const* buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->img_buffer = s->img_buffer_original = (uint8*)buffer; + s->img_buffer_end = (uint8*)buffer + len; +} + +// initialize a callback-based context +static void start_callbacks(stbi* s, stbi_io_callbacks* c, void* user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->img_buffer_original = s->buffer_start; + refill_buffer(s); +} + +#ifndef STBI_NO_STDIO + +static int stdio_read(void* user, char* data, int size) +{ + return (int)fread(data, 1, size, (FILE*)user); +} + +static void stdio_skip(void* user, unsigned n) +{ + fseek((FILE*)user, n, SEEK_CUR); +} + +static int stdio_eof(void* user) +{ + return feof((FILE*)user); +} + +static stbi_io_callbacks stbi_stdio_callbacks = { + stdio_read, + stdio_skip, + stdio_eof, +}; + +static void start_file(stbi* s, FILE* f) +{ + start_callbacks(s, &stbi_stdio_callbacks, (void*)f); +} + +// static void stop_file(stbi *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi_rewind(stbi* s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; +} + +static int stbi_jpeg_test(stbi* s); +static stbi_uc* stbi_jpeg_load(stbi* s, int* x, int* y, int* comp, int req_comp); +static int stbi_jpeg_info(stbi* s, int* x, int* y, int* comp); +static int stbi_png_test(stbi* s); +static stbi_uc* stbi_png_load(stbi* s, int* x, int* y, int* comp, int req_comp); +static int stbi_png_info(stbi* s, int* x, int* y, int* comp); +static int stbi_bmp_test(stbi* s); +static stbi_uc* stbi_bmp_load(stbi* s, int* x, int* y, int* comp, int req_comp); +static int stbi_tga_test(stbi* s); +static stbi_uc* stbi_tga_load(stbi* s, int* x, int* y, int* comp, int req_comp); +static int stbi_tga_info(stbi* s, int* x, int* y, int* comp); +static int stbi_psd_test(stbi* s); +static stbi_uc* stbi_psd_load(stbi* s, int* x, int* y, int* comp, int req_comp); +static int stbi_hdr_test(stbi* s); +static float* stbi_hdr_load(stbi* s, int* x, int* y, int* comp, int req_comp); +static int stbi_pic_test(stbi* s); +static stbi_uc* stbi_pic_load(stbi* s, int* x, int* y, int* comp, int req_comp); +static int stbi_gif_test(stbi* s); +static stbi_uc* stbi_gif_load(stbi* s, int* x, int* y, int* comp, int req_comp); +static int stbi_gif_info(stbi* s, int* x, int* y, int* comp); + +// this is not threadsafe +static const char* failure_reason; + +const char* stbi_failure_reason(void) +{ + return failure_reason; +} + +static int e(const char* str) +{ + failure_reason = str; + return 0; +} + +// e - error +// epf - error returning pointer to float +// epuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS +#define e(x, y) 0 +#elif defined(STBI_FAILURE_USERMSG) +#define e(x, y) e(y) +#else +#define e(x, y) e(x) +#endif + +#define epf(x, y) ((float*)(e(x, y) ? NULL : NULL)) +#define epuc(x, y) ((unsigned char*)(e(x, y) ? NULL : NULL)) + +void stbi_image_free(void* retval_from_stbi_load) +{ + free(retval_from_stbi_load); +} + +#ifndef STBI_NO_HDR +static float* ldr_to_hdr(stbi_uc* data, int x, int y, int comp); +static stbi_uc* hdr_to_ldr(float* data, int x, int y, int comp); +#endif + +static unsigned char* stbi_load_main(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + if (stbi_jpeg_test(s)) + return stbi_jpeg_load(s, x, y, comp, req_comp); + if (stbi_png_test(s)) + return stbi_png_load(s, x, y, comp, req_comp); + if (stbi_bmp_test(s)) + return stbi_bmp_load(s, x, y, comp, req_comp); + if (stbi_gif_test(s)) + return stbi_gif_load(s, x, y, comp, req_comp); + if (stbi_psd_test(s)) + return stbi_psd_load(s, x, y, comp, req_comp); + if (stbi_pic_test(s)) + return stbi_pic_load(s, x, y, comp, req_comp); + +#ifndef STBI_NO_HDR + if (stbi_hdr_test(s)) + { + float* hdr = stbi_hdr_load(s, x, y, comp, req_comp); + return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } +#endif + + // test tga last because it's a crappy test! + if (stbi_tga_test(s)) + return stbi_tga_load(s, x, y, comp, req_comp); + return epuc("unknown image type", "Image not of any known type, or corrupt"); +} + +#ifndef STBI_NO_STDIO +unsigned char* stbi_load(char const* filename, int* x, int* y, int* comp, int req_comp) +{ + FILE* f = fopen(filename, "rb"); + unsigned char* result; + if (!f) + return epuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f, x, y, comp, req_comp); + fclose(f); + return result; +} + +unsigned char* stbi_load_from_file(FILE* f, int* x, int* y, int* comp, int req_comp) +{ + stbi s; + start_file(&s, f); + return stbi_load_main(&s, x, y, comp, req_comp); +} +#endif //! STBI_NO_STDIO + +unsigned char* stbi_load_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp, + int req_comp) +{ + stbi s; + start_mem(&s, buffer, len); + return stbi_load_main(&s, x, y, comp, req_comp); +} + +unsigned char* stbi_load_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, int* y, + int* comp, int req_comp) +{ + stbi s; + start_callbacks(&s, (stbi_io_callbacks*)clbk, user); + return stbi_load_main(&s, x, y, comp, req_comp); +} + +#ifndef STBI_NO_HDR + +float* stbi_loadf_main(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + unsigned char* data; +#ifndef STBI_NO_HDR + if (stbi_hdr_test(s)) + return stbi_hdr_load(s, x, y, comp, req_comp); +#endif + data = stbi_load_main(s, x, y, comp, req_comp); + if (data) + return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return epf("unknown image type", "Image not of any known type, or corrupt"); +} + +float* stbi_loadf_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp, + int req_comp) +{ + stbi s; + start_mem(&s, buffer, len); + return stbi_loadf_main(&s, x, y, comp, req_comp); +} + +float* stbi_loadf_from_callbacks(stbi_io_callbacks const* clbk, void* user, int* x, int* y, + int* comp, int req_comp) +{ + stbi s; + start_callbacks(&s, (stbi_io_callbacks*)clbk, user); + return stbi_loadf_main(&s, x, y, comp, req_comp); +} + +#ifndef STBI_NO_STDIO +float* stbi_loadf(char const* filename, int* x, int* y, int* comp, int req_comp) +{ + FILE* f = fopen(filename, "rb"); + float* result; + if (!f) + return epf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f, x, y, comp, req_comp); + fclose(f); + return result; +} + +float* stbi_loadf_from_file(FILE* f, int* x, int* y, int* comp, int req_comp) +{ + stbi s; + start_file(&s, f); + return stbi_loadf_main(&s, x, y, comp, req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_HDR + +// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is +// defined, for API simplicity; if STBI_NO_HDR is defined, it always +// reports false! + +int stbi_is_hdr_from_memory(stbi_uc const* buffer, int len) +{ +#ifndef STBI_NO_HDR + stbi s; + start_mem(&s, buffer, len); + return stbi_hdr_test(&s); +#else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; +#endif +} + +#ifndef STBI_NO_STDIO +extern int stbi_is_hdr(char const* filename) +{ + FILE* f = fopen(filename, "rb"); + int result = 0; + if (f) + { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +extern int stbi_is_hdr_from_file(FILE* f) +{ +#ifndef STBI_NO_HDR + stbi s; + start_file(&s, f); + return stbi_hdr_test(&s); +#else + return 0; +#endif +} +#endif // !STBI_NO_STDIO + +extern int stbi_is_hdr_from_callbacks(stbi_io_callbacks const* clbk, void* user) +{ +#ifndef STBI_NO_HDR + stbi s; + start_callbacks(&s, (stbi_io_callbacks*)clbk, user); + return stbi_hdr_test(&s); +#else + return 0; +#endif +} + +#ifndef STBI_NO_HDR +static float h2l_gamma_i = 1.0f / 2.2f, h2l_scale_i = 1.0f; +static float l2h_gamma = 2.2f, l2h_scale = 1.0f; + +void stbi_hdr_to_ldr_gamma(float gamma) +{ + h2l_gamma_i = 1 / gamma; +} +void stbi_hdr_to_ldr_scale(float scale) +{ + h2l_scale_i = 1 / scale; +} + +void stbi_ldr_to_hdr_gamma(float gamma) +{ + l2h_gamma = gamma; +} +void stbi_ldr_to_hdr_scale(float scale) +{ + l2h_scale = scale; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + SCAN_load = 0, + SCAN_type, + SCAN_header +}; + +static void refill_buffer(stbi* s) +{ + int n = (s->io.read)(s->io_user_data, (char*)s->buffer_start, s->buflen); + if (n == 0) + { + // at end of file, treat same as if from memory + s->read_from_callbacks = 0; + s->img_buffer = s->img_buffer_end - 1; + *s->img_buffer = 0; + } + else + { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static int get8(stbi* s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) + { + refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +stbi_inline static int at_eof(stbi* s) +{ + if (s->io.read) + { + if (!(s->io.eof)(s->io_user_data)) + return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) + return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} + +stbi_inline static uint8 get8u(stbi* s) +{ + return (uint8)get8(s); +} + +static void skip(stbi* s, int n) +{ + if (s->io.read) + { + int blen = s->img_buffer_end - s->img_buffer; + if (blen < n) + { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} + +static int getn(stbi* s, stbi_uc* buffer, int n) +{ + if (s->io.read) + { + int blen = s->img_buffer_end - s->img_buffer; + if (blen < n) + { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*)buffer + blen, n - blen); + res = (count == (n - blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer + n <= s->img_buffer_end) + { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } + else + return 0; +} + +static int get16(stbi* s) +{ + int z = get8(s); + return (z << 8) + get8(s); +} + +static uint32 get32(stbi* s) +{ + uint32 z = get16(s); + return (z << 16) + get16(s); +} + +static int get16le(stbi* s) +{ + int z = get8(s); + return z + (get8(s) << 8); +} + +static uint32 get32le(stbi* s) +{ + uint32 z = get16le(s); + return z + (get16le(s) << 16); +} + +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static uint8 compute_y(int r, int g, int b) +{ + return (uint8)(((r * 77) + (g * 150) + (29 * b)) >> 8); +} + +static unsigned char* convert_format(unsigned char* data, int img_n, int req_comp, uint x, uint y) +{ + int i, j; + unsigned char* good; + + if (req_comp == img_n) + return data; + assert(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char*)malloc(req_comp * x * y); + if (good == NULL) + { + free(data); + return epuc("outofmem", "Out of memory"); + } + + for (j = 0; j < (int)y; ++j) + { + unsigned char* src = data + j * x * img_n; + unsigned char* dest = good + j * x * req_comp; + +#define COMBO(a, b) ((a) * 8 + (b)) +#define CASE(a, b) \ + case COMBO(a, b): \ + for (i = x - 1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (COMBO(img_n, req_comp)) + { + CASE(1, 2) dest[0] = src[0], dest[1] = 255; + break; + CASE(1, 3) dest[0] = dest[1] = dest[2] = src[0]; + break; + CASE(1, 4) dest[0] = dest[1] = dest[2] = src[0], dest[3] = 255; + break; + CASE(2, 1) dest[0] = src[0]; + break; + CASE(2, 3) dest[0] = dest[1] = dest[2] = src[0]; + break; + CASE(2, 4) dest[0] = dest[1] = dest[2] = src[0], dest[3] = src[1]; + break; + CASE(3, 4) dest[0] = src[0], dest[1] = src[1], dest[2] = src[2], dest[3] = 255; + break; + CASE(3, 1) dest[0] = compute_y(src[0], src[1], src[2]); + break; + CASE(3, 2) dest[0] = compute_y(src[0], src[1], src[2]), dest[1] = 255; + break; + CASE(4, 1) dest[0] = compute_y(src[0], src[1], src[2]); + break; + CASE(4, 2) dest[0] = compute_y(src[0], src[1], src[2]), dest[1] = src[3]; + break; + CASE(4, 3) dest[0] = src[0], dest[1] = src[1], dest[2] = src[2]; + break; + default: + assert(0); + } +#undef CASE + } + + free(data); + return good; +} + +#ifndef STBI_NO_HDR +static float* ldr_to_hdr(stbi_uc* data, int x, int y, int comp) +{ + int i, k, n; + float* output = (float*)malloc(x * y * comp * sizeof(float)); + if (output == NULL) + { + free(data); + return epf("outofmem", "Out of memory"); + } + // compute number of non-alpha components + if (comp & 1) + n = comp; + else + n = comp - 1; + for (i = 0; i < x * y; ++i) + { + for (k = 0; k < n; ++k) + { + output[i * comp + k] = (float)pow(data[i * comp + k] / 255.0f, l2h_gamma) * l2h_scale; + } + if (k < comp) + output[i * comp + k] = data[i * comp + k] / 255.0f; + } + free(data); + return output; +} + +#define float2int(x) ((int)(x)) +static stbi_uc* hdr_to_ldr(float* data, int x, int y, int comp) +{ + int i, k, n; + stbi_uc* output = (stbi_uc*)malloc(x * y * comp); + if (output == NULL) + { + free(data); + return epuc("outofmem", "Out of memory"); + } + // compute number of non-alpha components + if (comp & 1) + n = comp; + else + n = comp - 1; + for (i = 0; i < x * y; ++i) + { + for (k = 0; k < n; ++k) + { + float z = (float)pow(data[i * comp + k] * h2l_scale_i, h2l_gamma_i) * 255 + 0.5f; + if (z < 0) + z = 0; + if (z > 255) + z = 255; + output[i * comp + k] = (uint8)float2int(z); + } + if (k < comp) + { + float z = data[i * comp + k] * 255 + 0.5f; + if (z < 0) + z = 0; + if (z > 255) + z = 255; + output[i * comp + k] = (uint8)float2int(z); + } + } + free(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder (not actually fully baseline implementation) +// +// simple implementation +// - channel subsampling of at most 2 in each dimension +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - uses a lot of intermediate memory, could cache poorly +// - loadSound http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4 +// stb_jpeg: 1.34 seconds (MSVC6, default release build) +// stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro) +// IJL11.dll: 1.08 seconds (compiled by intel) +// IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG) +// IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro) + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + uint8 fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% mSpeed loss, instead of a win + uint16 code[256]; + uint8 values[256]; + uint8 size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} huffman; + +typedef struct +{ +#ifdef STBI_SIMD + unsigned short dequant2[4][64]; +#endif + stbi* s; + huffman huff_dc[4]; + huffman huff_ac[4]; + uint8 dequant[4][64]; + + // sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + + // definition of jpeg image component + struct + { + int id; + int h, v; + int tq; + int hd, ha; + int dc_pred; + + int x, y, w2, h2; + uint8* data; + void* raw_data; + uint8* linebuf; + } img_comp[4]; + + uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int scan_n, order[4]; + int restart_interval, todo; +} jpeg; + +static int build_huffman(huffman* h, int* count) +{ + int i, j, k = 0, code; + // build size list for each symbol (from JPEG spec) + for (i = 0; i < 16; ++i) + for (j = 0; j < count[i]; ++j) + h->size[k++] = (uint8)(i + 1); + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for (j = 1; j <= 16; ++j) + { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) + { + while (h->size[k] == j) + h->code[k++] = (uint16)(code++); + if (code - 1 >= (1 << j)) + return e("bad code lengths", "Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16 - j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i = 0; i < k; ++i) + { + int s = h->size[i]; + if (s <= FAST_BITS) + { + int c = h->code[i] << (FAST_BITS - s); + int m = 1 << (FAST_BITS - s); + for (j = 0; j < m; ++j) + { + h->fast[c + j] = (uint8)i; + } + } + } + return 1; +} + +static void grow_buffer_unsafe(jpeg* j) +{ + do + { + int b = j->nomore ? 0 : get8(j->s); + if (b == 0xff) + { + int c = get8(j->s); + if (c != 0) + { + j->marker = (unsigned char)c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static uint32 bmask[17] = {0, 1, 3, 7, 15, 31, 63, 127, 255, + 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int decode(jpeg* j, huffman* h) +{ + unsigned int temp; + int c, k; + + if (j->code_bits < 16) + grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS) - 1); + k = h->fast[c]; + if (k < 255) + { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To mSpeed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k = FAST_BITS + 1;; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) + { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & bmask[k]) + h->delta[k]; + assert((((j->code_buffer) >> (32 - h->size[c])) & bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// combined JPEG 'receive' and JPEG 'extend', since baseline +// always extends everything it receives. +stbi_inline static int extend_receive(jpeg* j, int n) +{ + unsigned int m = 1 << (n - 1); + unsigned int k; + if (j->code_bits < n) + grow_buffer_unsafe(j); + +#if 1 + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~bmask[n]; + k &= bmask[n]; + j->code_bits -= n; +#else + k = (j->code_buffer >> (32 - n)) & bmask[n]; + j->code_bits -= n; + j->code_buffer <<= n; +#endif + // the following test is probably a random branch that won't + // predict well. I tried to table accelerate it but failed. + // maybe it's compiling as a conditional move? + if (k < m) + return (-1 << n) + k + 1; + else + return k; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static uint8 dezigzag[64 + 15] = {0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, + 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, + 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, + 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63}; + +// decode one 64-entry block-- +static int decode_block(jpeg* j, short data[64], huffman* hdc, huffman* hac, int b) +{ + int diff, dc, k; + int t = decode(j, hdc); + if (t < 0) + return e("bad huffman code", "Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data, 0, 64 * sizeof(data[0])); + + diff = t ? extend_receive(j, t) : 0; + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short)dc; + + // decode AC components, see JPEG spec + k = 1; + do + { + int r, s; + int rs = decode(j, hac); + if (rs < 0) + return e("bad huffman code", "Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) + { + if (rs != 0xf0) + break; // end block + k += 16; + } + else + { + k += r; + // decode into unzigzag'd location + data[dezigzag[k++]] = (short)extend_receive(j, s); + } + } while (k < 64); + return 1; +} + +// take a -128..127 value and clamp it and convert to 0..255 +stbi_inline static uint8 clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int)x > 255) + { + if (x < 0) + return 0; + if (x > 255) + return 255; + } + return (uint8)x; +} + +#define f2f(x) (int)(((x) * 4096 + 0.5)) +#define fsh(x) ((x) << 12) + +// derived from jidctint -- DCT_ISLOW +#define IDCT_1D(s0, s1, s2, s3, s4, s5, s6, s7) \ + int t0, t1, t2, t3, p1, p2, p3, p4, p5, x0, x1, x2, x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2 + p3) * f2f(0.5411961f); \ + t2 = p1 + p3 * f2f(-1.847759065f); \ + t3 = p1 + p2 * f2f(0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = fsh(p2 + p3); \ + t1 = fsh(p2 - p3); \ + x0 = t0 + t3; \ + x3 = t0 - t3; \ + x1 = t1 + t2; \ + x2 = t1 - t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0 + t2; \ + p4 = t1 + t3; \ + p1 = t0 + t3; \ + p2 = t1 + t2; \ + p5 = (p3 + p4) * f2f(1.175875602f); \ + t0 = t0 * f2f(0.298631336f); \ + t1 = t1 * f2f(2.053119869f); \ + t2 = t2 * f2f(3.072711026f); \ + t3 = t3 * f2f(1.501321110f); \ + p1 = p5 + p1 * f2f(-0.899976223f); \ + p2 = p5 + p2 * f2f(-2.562915447f); \ + p3 = p3 * f2f(-1.961570560f); \ + p4 = p4 * f2f(-0.390180644f); \ + t3 += p1 + p4; \ + t2 += p2 + p3; \ + t1 += p2 + p4; \ + t0 += p1 + p3; + +#ifdef STBI_SIMD +typedef unsigned short stbi_dequantize_t; +#else +typedef uint8 stbi_dequantize_t; +#endif + +// .344 seconds on 3*anemones.jpg +static void idct_block(uint8* out, int out_stride, short data[64], stbi_dequantize_t* dequantize) +{ + int i, val[64], *v = val; + stbi_dequantize_t* dq = dequantize; + uint8* o; + short* d = data; + + // columns + for (i = 0; i < 8; ++i, ++d, ++dq, ++v) + { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[8] == 0 && d[16] == 0 && d[24] == 0 && d[32] == 0 && d[40] == 0 && d[48] == 0 && + d[56] == 0) + { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0] * dq[0] << 2; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } + else + { + IDCT_1D(d[0] * dq[0], d[8] * dq[8], d[16] * dq[16], d[24] * dq[24], d[32] * dq[32], + d[40] * dq[40], d[48] * dq[48], d[56] * dq[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; + x1 += 512; + x2 += 512; + x3 += 512; + v[0] = (x0 + t3) >> 10; + v[56] = (x0 - t3) >> 10; + v[8] = (x1 + t2) >> 10; + v[48] = (x1 - t2) >> 10; + v[16] = (x2 + t1) >> 10; + v[40] = (x2 - t1) >> 10; + v[24] = (x3 + t0) >> 10; + v[32] = (x3 - t0) >> 10; + } + } + + for (i = 0, v = val, o = out; i < 8; ++i, v += 8, o += out_stride) + { + // no fast case since the first 1D IDCT spread components out + IDCT_1D(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128 << 17); + x1 += 65536 + (128 << 17); + x2 += 65536 + (128 << 17); + x3 += 65536 + (128 << 17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = clamp((x0 + t3) >> 17); + o[7] = clamp((x0 - t3) >> 17); + o[1] = clamp((x1 + t2) >> 17); + o[6] = clamp((x1 - t2) >> 17); + o[2] = clamp((x2 + t1) >> 17); + o[5] = clamp((x2 - t1) >> 17); + o[3] = clamp((x3 + t0) >> 17); + o[4] = clamp((x3 - t0) >> 17); + } +} + +#ifdef STBI_SIMD +static stbi_idct_8x8 stbi_idct_installed = idct_block; + +void stbi_install_idct(stbi_idct_8x8 func) +{ + stbi_idct_installed = func; +} +#endif + +#define MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static uint8 get_marker(jpeg* j) +{ + uint8 x; + if (j->marker != MARKER_none) + { + x = j->marker; + j->marker = MARKER_none; + return x; + } + x = get8u(j->s); + if (x != 0xff) + return MARKER_none; + while (x == 0xff) + x = get8u(j->s); + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, reset the entropy decoder and +// the dc prediction +static void reset(jpeg* j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0; + j->marker = MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int parse_entropy_coded_data(jpeg* z) +{ + reset(z); + if (z->scan_n == 1) + { + int i, j; +#ifdef STBI_SIMD + __declspec(align(16)) +#endif + short data[64]; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x + 7) >> 3; + int h = (z->img_comp[n].y + 7) >> 3; + for (j = 0; j < h; ++j) + { + for (i = 0; i < w; ++i) + { + if (!decode_block(z, data, z->huff_dc + z->img_comp[n].hd, + z->huff_ac + z->img_comp[n].ha, n)) + return 0; +#ifdef STBI_SIMD + stbi_idct_installed(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8, + z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]); +#else + idct_block(z->img_comp[n].data + z->img_comp[n].w2 * j * 8 + i * 8, + z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]); +#endif + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) + { + if (z->code_bits < 24) + grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!RESTART(z->marker)) + return 1; + reset(z); + } + } + } + } + else + { // interleaved! + int i, j, k, x, y; + short data[64]; + for (j = 0; j < z->img_mcu_y; ++j) + { + for (i = 0; i < z->img_mcu_x; ++i) + { + // scan an interleaved mcu... process scan_n components in order + for (k = 0; k < z->scan_n; ++k) + { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y = 0; y < z->img_comp[n].v; ++y) + { + for (x = 0; x < z->img_comp[n].h; ++x) + { + int x2 = (i * z->img_comp[n].h + x) * 8; + int y2 = (j * z->img_comp[n].v + y) * 8; + if (!decode_block(z, data, z->huff_dc + z->img_comp[n].hd, + z->huff_ac + z->img_comp[n].ha, n)) + return 0; +#ifdef STBI_SIMD + stbi_idct_installed(z->img_comp[n].data + z->img_comp[n].w2 * y2 + x2, + z->img_comp[n].w2, data, + z->dequant2[z->img_comp[n].tq]); +#else + idct_block(z->img_comp[n].data + z->img_comp[n].w2 * y2 + x2, + z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]); +#endif + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) + { + if (z->code_bits < 24) + grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!RESTART(z->marker)) + return 1; + reset(z); + } + } + } + } + return 1; +} + +static int process_marker(jpeg* z, int m) +{ + int L; + switch (m) + { + case MARKER_none: // no marker found + return e("expected marker", "Corrupt JPEG"); + + case 0xC2: // SOF - progressive + return e("progressive jpeg", "JPEG format not supported (progressive)"); + + case 0xDD: // DRI - specify restart interval + if (get16(z->s) != 4) + return e("bad DRI len", "Corrupt JPEG"); + z->restart_interval = get16(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = get16(z->s) - 2; + while (L > 0) + { + int q = get8(z->s); + int p = q >> 4; + int t = q & 15, i; + if (p != 0) + return e("bad DQT type", "Corrupt JPEG"); + if (t > 3) + return e("bad DQT table", "Corrupt JPEG"); + for (i = 0; i < 64; ++i) + z->dequant[t][dezigzag[i]] = get8u(z->s); +#ifdef STBI_SIMD + for (i = 0; i < 64; ++i) + z->dequant2[t][i] = z->dequant[t][i]; +#endif + L -= 65; + } + return L == 0; + + case 0xC4: // DHT - define huffman table + L = get16(z->s) - 2; + while (L > 0) + { + uint8* v; + int sizes[16], i, m = 0; + int q = get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) + return e("bad DHT header", "Corrupt JPEG"); + for (i = 0; i < 16; ++i) + { + sizes[i] = get8(z->s); + m += sizes[i]; + } + L -= 17; + if (tc == 0) + { + if (!build_huffman(z->huff_dc + th, sizes)) + return 0; + v = z->huff_dc[th].values; + } + else + { + if (!build_huffman(z->huff_ac + th, sizes)) + return 0; + v = z->huff_ac[th].values; + } + for (i = 0; i < m; ++i) + v[i] = get8u(z->s); + L -= m; + } + return L == 0; + } + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) + { + skip(z->s, get16(z->s) - 2); + return 1; + } + return 0; +} + +// after we see SOS +static int process_scan_header(jpeg* z) +{ + int i; + int Ls = get16(z->s); + z->scan_n = get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int)z->s->img_n) + return e("bad SOS component count", "Corrupt JPEG"); + if (Ls != 6 + 2 * z->scan_n) + return e("bad SOS len", "Corrupt JPEG"); + for (i = 0; i < z->scan_n; ++i) + { + int id = get8(z->s), which; + int q = get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) + return 0; + z->img_comp[which].hd = q >> 4; + if (z->img_comp[which].hd > 3) + return e("bad DC huff", "Corrupt JPEG"); + z->img_comp[which].ha = q & 15; + if (z->img_comp[which].ha > 3) + return e("bad AC huff", "Corrupt JPEG"); + z->order[i] = which; + } + if (get8(z->s) != 0) + return e("bad SOS", "Corrupt JPEG"); + get8(z->s); // should be 63, but might be 0 + if (get8(z->s) != 0) + return e("bad SOS", "Corrupt JPEG"); + + return 1; +} + +static int process_frame_header(jpeg* z, int scan) +{ + stbi* s = z->s; + int Lf, p, i, q, h_max = 1, v_max = 1, c; + Lf = get16(s); + if (Lf < 11) + return e("bad SOF len", "Corrupt JPEG"); // JPEG + p = get8(s); + if (p != 8) + return e("only 8-bit", "JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = get16(s); + if (s->img_y == 0) + return e("no header mHeight", + "JPEG format not supported: delayed mHeight"); // Legal, but we don't handle + // it--but neither does IJG + s->img_x = get16(s); + if (s->img_x == 0) + return e("0 mWidth", "Corrupt JPEG"); // JPEG requires + c = get8(s); + if (c != 3 && c != 1) + return e("bad component count", "Corrupt JPEG"); // JFIF requires + s->img_n = c; + for (i = 0; i < c; ++i) + { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8 + 3 * s->img_n) + return e("bad SOF len", "Corrupt JPEG"); + + for (i = 0; i < s->img_n; ++i) + { + z->img_comp[i].id = get8(s); + if (z->img_comp[i].id != i + 1) // JFIF requires + if (z->img_comp[i].id != + i) // some version of jpegtran outputs non-JFIF-compliant files! + return e("bad component ID", "Corrupt JPEG"); + q = get8(s); + z->img_comp[i].h = (q >> 4); + if (!z->img_comp[i].h || z->img_comp[i].h > 4) + return e("bad H", "Corrupt JPEG"); + z->img_comp[i].v = q & 15; + if (!z->img_comp[i].v || z->img_comp[i].v > 4) + return e("bad V", "Corrupt JPEG"); + z->img_comp[i].tq = get8(s); + if (z->img_comp[i].tq > 3) + return e("bad TQ", "Corrupt JPEG"); + } + + if (scan != SCAN_load) + return 1; + + if ((1 << 30) / s->img_x / s->img_n < s->img_y) + return e("too large", "Image too large to decode"); + + for (i = 0; i < s->img_n; ++i) + { + if (z->img_comp[i].h > h_max) + h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) + v_max = z->img_comp[i].v; + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + z->img_mcu_x = (s->img_x + z->img_mcu_w - 1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h - 1) / z->img_mcu_h; + + for (i = 0; i < s->img_n; ++i) + { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max - 1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max - 1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of mWidth 33); we won't + // discard the extra data until colorspace conversion + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2 + 15); + if (z->img_comp[i].raw_data == NULL) + { + for (--i; i >= 0; --i) + { + free(z->img_comp[i].raw_data); + z->img_comp[i].data = NULL; + } + return e("outofmem", "Out of memory"); + } + // align blocks for installable-idct using mmx/sse + z->img_comp[i].data = (uint8*)(((size_t)z->img_comp[i].raw_data + 15) & ~15); + z->img_comp[i].linebuf = NULL; + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define DNL(x) ((x) == 0xdc) +#define SOI(x) ((x) == 0xd8) +#define EOI(x) ((x) == 0xd9) +#define SOF(x) ((x) == 0xc0 || (x) == 0xc1) +#define SOS(x) ((x) == 0xda) + +static int decode_jpeg_header(jpeg* z, int scan) +{ + int m; + z->marker = MARKER_none; // initialize cached marker to empty + m = get_marker(z); + if (!SOI(m)) + return e("no SOI", "Corrupt JPEG"); + if (scan == SCAN_type) + return 1; + m = get_marker(z); + while (!SOF(m)) + { + if (!process_marker(z, m)) + return 0; + m = get_marker(z); + while (m == MARKER_none) + { + // some files have extra padding after their blocks, so ok, we'll scan + if (at_eof(z->s)) + return e("no SOF", "Corrupt JPEG"); + m = get_marker(z); + } + } + if (!process_frame_header(z, scan)) + return 0; + return 1; +} + +static int decode_jpeg_image(jpeg* j) +{ + int m; + j->restart_interval = 0; + if (!decode_jpeg_header(j, SCAN_load)) + return 0; + m = get_marker(j); + while (!EOI(m)) + { + if (SOS(m)) + { + if (!process_scan_header(j)) + return 0; + if (!parse_entropy_coded_data(j)) + return 0; + if (j->marker == MARKER_none) + { + // handle 0s at the end of image data from IP Kamera 9060 + while (!at_eof(j->s)) + { + int x = get8(j->s); + if (x == 255) + { + j->marker = get8u(j->s); + break; + } + else if (x != 0) + { + return 0; + } + } + // if we reach eof without hitting a marker, get_marker() below will fail and we'll + // eventually return 0 + } + } + else + { + if (!process_marker(j, m)) + return 0; + } + m = get_marker(j); + } + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef uint8* (*resample_row_func)(uint8* out, uint8* in0, uint8* in1, int w, int hs); + +#define div4(x) ((uint8)((x) >> 2)) + +static uint8* resample_row_1(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static uint8* resample_row_v_2(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i = 0; i < w; ++i) + out[i] = div4(3 * in_near[i] + in_far[i] + 2); + return out; +} + +static uint8* resample_row_h_2(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + uint8* input = in_near; + + if (w == 1) + { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = div4(input[0] * 3 + input[1] + 2); + for (i = 1; i < w - 1; ++i) + { + int n = 3 * input[i] + 2; + out[i * 2 + 0] = div4(n + input[i - 1]); + out[i * 2 + 1] = div4(n + input[i + 1]); + } + out[i * 2 + 0] = div4(input[w - 2] * 3 + input[w - 1] + 2); + out[i * 2 + 1] = input[w - 1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define div16(x) ((uint8)((x) >> 4)) + +static uint8* resample_row_hv_2(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i, t0, t1; + if (w == 1) + { + out[0] = out[1] = div4(3 * in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3 * in_near[0] + in_far[0]; + out[0] = div4(t1 + 2); + for (i = 1; i < w; ++i) + { + t0 = t1; + t1 = 3 * in_near[i] + in_far[i]; + out[i * 2 - 1] = div16(3 * t0 + t1 + 8); + out[i * 2] = div16(3 * t1 + t0 + 8); + } + out[w * 2 - 1] = div4(t1 + 2); + + STBI_NOTUSED(hs); + + return out; +} + +static uint8* resample_row_generic(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i, j; + in_far = in_far; + for (i = 0; i < w; ++i) + for (j = 0; j < hs; ++j) + out[i * hs + j] = in_near[i]; + return out; +} + +#define float2fixed(x) ((int)((x) * 65536 + 0.5)) + +// 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro) +// VC6 without processor=Pro is generating multiple LEAs per multiply! +static void YCbCr_to_RGB_row(uint8* out, const uint8* y, const uint8* pcb, const uint8* pcr, + int count, int step) +{ + int i; + for (i = 0; i < count; ++i) + { + int y_fixed = (y[i] << 16) + 32768; // rounding + int r, g, b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr * float2fixed(1.40200f); + g = y_fixed - cr * float2fixed(0.71414f) - cb * float2fixed(0.34414f); + b = y_fixed + cb * float2fixed(1.77200f); + r >>= 16; + g >>= 16; + b >>= 16; + if ((unsigned)r > 255) + { + if (r < 0) + r = 0; + else + r = 255; + } + if ((unsigned)g > 255) + { + if (g < 0) + g = 0; + else + g = 255; + } + if ((unsigned)b > 255) + { + if (b < 0) + b = 0; + else + b = 255; + } + out[0] = (uint8)r; + out[1] = (uint8)g; + out[2] = (uint8)b; + out[3] = 255; + out += step; + } +} + +#ifdef STBI_SIMD +static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed = YCbCr_to_RGB_row; + +void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func) +{ + stbi_YCbCr_installed = func; +} +#endif + +// clean up the temporary component buffers +static void cleanup_jpeg(jpeg* j) +{ + int i; + for (i = 0; i < j->s->img_n; ++i) + { + if (j->img_comp[i].data) + { + free(j->img_comp[i].raw_data); + j->img_comp[i].data = NULL; + } + if (j->img_comp[i].linebuf) + { + free(j->img_comp[i].linebuf); + j->img_comp[i].linebuf = NULL; + } + } +} + +typedef struct +{ + resample_row_func resample; + uint8 *line0, *line1; + int hs, vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi_resample; + +static uint8* load_jpeg_image(jpeg* z, int* out_x, int* out_y, int* comp, int req_comp) +{ + int n, decode_n; + // validate req_comp + if (req_comp < 0 || req_comp > 4) + return epuc("bad req_comp", "Internal error"); + z->s->img_n = 0; + + // loadSound a jpeg image from whichever source + if (!decode_jpeg_image(z)) + { + cleanup_jpeg(z); + return NULL; + } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n; + + if (z->s->img_n == 3 && n < 3) + decode_n = 1; + else + decode_n = z->s->img_n; + + // resample and mColor-convert + { + int k; + uint i, j; + uint8* output; + uint8* coutput[4]; + + stbi_resample res_comp[4]; + + for (k = 0; k < decode_n; ++k) + { + stbi_resample* r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (uint8*)malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) + { + cleanup_jpeg(z); + return epuc("outofmem", "Out of memory"); + } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs - 1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) + r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) + r->resample = resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) + r->resample = resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) + r->resample = resample_row_hv_2; + else + r->resample = resample_row_generic; + } + + // can't error after this so, this is safe + output = (uint8*)malloc(n * z->s->img_x * z->s->img_y + 1); + if (!output) + { + cleanup_jpeg(z); + return epuc("outofmem", "Out of memory"); + } + + // now go ahead and resample + for (j = 0; j < z->s->img_y; ++j) + { + uint8* out = output + n * z->s->img_x * j; + for (k = 0; k < decode_n; ++k) + { + stbi_resample* r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, r->w_lores, r->hs); + if (++r->ystep >= r->vs) + { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) + { + uint8* y = coutput[0]; + if (z->s->img_n == 3) + { +#ifdef STBI_SIMD + stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n); +#else + YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s->img_x, n); +#endif + } + else + for (i = 0; i < z->s->img_x; ++i) + { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } + else + { + uint8* y = coutput[0]; + if (n == 1) + for (i = 0; i < z->s->img_x; ++i) + out[i] = y[i]; + else + for (i = 0; i < z->s->img_x; ++i) + *out++ = y[i], *out++ = 255; + } + } + cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) + *comp = z->s->img_n; // report original components, not output + return output; + } +} + +static unsigned char* stbi_jpeg_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + jpeg j; + j.s = s; + return load_jpeg_image(&j, x, y, comp, req_comp); +} + +static int stbi_jpeg_test(stbi* s) +{ + int r; + jpeg j; + j.s = s; + r = decode_jpeg_header(&j, SCAN_type); + stbi_rewind(s); + return r; +} + +static int stbi_jpeg_info_raw(jpeg* j, int* x, int* y, int* comp) +{ + if (!decode_jpeg_header(j, SCAN_header)) + { + stbi_rewind(j->s); + return 0; + } + if (x) + *x = j->s->img_x; + if (y) + *y = j->s->img_y; + if (comp) + *comp = j->s->img_n; + return 1; +} + +static int stbi_jpeg_info(stbi* s, int* x, int* y, int* comp) +{ + jpeg j; + j.s = s; + return stbi_jpeg_info_raw(&j, x, y, comp); +} + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define ZFAST_BITS 9 // accelerate all cases in default tables +#define ZFAST_MASK ((1 << ZFAST_BITS) - 1) + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + uint16 fast[1 << ZFAST_BITS]; + uint16 firstcode[16]; + int maxcode[17]; + uint16 firstsymbol[16]; + uint8 size[288]; + uint16 value[288]; +} zhuffman; + +stbi_inline static int bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int bit_reverse(int v, int bits) +{ + assert(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return bitreverse16(v) >> (16 - bits); +} + +static int zbuild_huffman(zhuffman* z, uint8* sizelist, int num) +{ + int i, k = 0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 255, sizeof(z->fast)); + for (i = 0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i = 1; i < 16; ++i) + assert(sizes[i] <= (1 << i)); + code = 0; + for (i = 1; i < 16; ++i) + { + next_code[i] = code; + z->firstcode[i] = (uint16)code; + z->firstsymbol[i] = (uint16)k; + code = (code + sizes[i]); + if (sizes[i]) + if (code - 1 >= (1 << i)) + return e("bad codelengths", "Corrupt JPEG"); + z->maxcode[i] = code << (16 - i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i = 0; i < num; ++i) + { + int s = sizelist[i]; + if (s) + { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + z->size[c] = (uint8)s; + z->value[c] = (uint16)i; + if (s <= ZFAST_BITS) + { + int k = bit_reverse(next_code[s], s); + while (k < (1 << ZFAST_BITS)) + { + z->fast[k] = (uint16)c; + k += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + uint8 *zbuffer, *zbuffer_end; + int num_bits; + uint32 code_buffer; + + char* zout; + char* zout_start; + char* zout_end; + int z_expandable; + + zhuffman z_length, z_distance; +} zbuf; + +stbi_inline static int zget8(zbuf* z) +{ + if (z->zbuffer >= z->zbuffer_end) + return 0; + return *z->zbuffer++; +} + +static void fill_bits(zbuf* z) +{ + do + { + assert(z->code_buffer < (1U << z->num_bits)); + z->code_buffer |= zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int zreceive(zbuf* z, int n) +{ + unsigned int k; + if (z->num_bits < n) + fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +stbi_inline static int zhuffman_decode(zbuf* a, zhuffman* z) +{ + int b, s, k; + if (a->num_bits < 16) + fill_bits(a); + b = z->fast[a->code_buffer & ZFAST_MASK]; + if (b < 0xffff) + { + s = z->size[b]; + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; + } + + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = bit_reverse(a->code_buffer, 16); + for (s = ZFAST_BITS + 1;; ++s) + if (k < z->maxcode[s]) + break; + if (s == 16) + return -1; // invalid code! + // code size is s, so: + b = (k >> (16 - s)) - z->firstcode[s] + z->firstsymbol[s]; + assert(z->size[b] == s); + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +static int expand(zbuf* z, int n) // need to make room for n bytes +{ + char* q; + int cur, limit; + if (!z->z_expandable) + return e("output buffer limit", "Corrupt PNG"); + cur = (int)(z->zout - z->zout_start); + limit = (int)(z->zout_end - z->zout_start); + while (cur + n > limit) + limit *= 2; + q = (char*)realloc(z->zout_start, limit); + if (q == NULL) + return e("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static int length_base[31] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + +static int length_extra[31] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, + 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0}; + +static int dist_base[32] = {1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, + 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, + 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0}; + +static int dist_extra[32] = {0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, + 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; + +static int parse_huffman_block(zbuf* a) +{ + for (;;) + { + int z = zhuffman_decode(a, &a->z_length); + if (z < 256) + { + if (z < 0) + return e("bad huffman code", "Corrupt PNG"); // error in huffman codes + if (a->zout >= a->zout_end) + if (!expand(a, 1)) + return 0; + *a->zout++ = (char)z; + } + else + { + uint8* p; + int len, dist; + if (z == 256) + return 1; + z -= 257; + len = length_base[z]; + if (length_extra[z]) + len += zreceive(a, length_extra[z]); + z = zhuffman_decode(a, &a->z_distance); + if (z < 0) + return e("bad huffman code", "Corrupt PNG"); + dist = dist_base[z]; + if (dist_extra[z]) + dist += zreceive(a, dist_extra[z]); + if (a->zout - a->zout_start < dist) + return e("bad dist", "Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!expand(a, len)) + return 0; + p = (uint8*)(a->zout - dist); + while (len--) + *a->zout++ = *p++; + } + } +} + +static int compute_huffman_codes(zbuf* a) +{ + static uint8 length_dezigzag[19] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, + 11, 4, 12, 3, 13, 2, 14, 1, 15}; + zhuffman z_codelength; + uint8 lencodes[286 + 32 + 137]; // padding for maximum single op + uint8 codelength_sizes[19]; + int i, n; + + int hlit = zreceive(a, 5) + 257; + int hdist = zreceive(a, 5) + 1; + int hclen = zreceive(a, 4) + 4; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i = 0; i < hclen; ++i) + { + int s = zreceive(a, 3); + codelength_sizes[length_dezigzag[i]] = (uint8)s; + } + if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) + return 0; + + n = 0; + while (n < hlit + hdist) + { + int c = zhuffman_decode(a, &z_codelength); + assert(c >= 0 && c < 19); + if (c < 16) + lencodes[n++] = (uint8)c; + else if (c == 16) + { + c = zreceive(a, 2) + 3; + memset(lencodes + n, lencodes[n - 1], c); + n += c; + } + else if (c == 17) + { + c = zreceive(a, 3) + 3; + memset(lencodes + n, 0, c); + n += c; + } + else + { + assert(c == 18); + c = zreceive(a, 7) + 11; + memset(lencodes + n, 0, c); + n += c; + } + } + if (n != hlit + hdist) + return e("bad codelengths", "Corrupt PNG"); + if (!zbuild_huffman(&a->z_length, lencodes, hlit)) + return 0; + if (!zbuild_huffman(&a->z_distance, lencodes + hlit, hdist)) + return 0; + return 1; +} + +static int parse_uncompressed_block(zbuf* a) +{ + uint8 header[4]; + int len, nlen, k; + if (a->num_bits & 7) + zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) + { + header[k++] = (uint8)(a->code_buffer & 255); // wtf this warns? + a->code_buffer >>= 8; + a->num_bits -= 8; + } + assert(a->num_bits == 0); + // now fill header the normal way + while (k < 4) + header[k++] = (uint8)zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) + return e("zlib corrupt", "Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) + return e("read past buffer", "Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!expand(a, len)) + return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int parse_zlib_header(zbuf* a) +{ + int cmf = zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = zget8(a); + if ((cmf * 256 + flg) % 31 != 0) + return e("bad zlib header", "Corrupt PNG"); // zlib spec + if (flg & 32) + return e("no preset dict", "Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) + return e("bad compression", "Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +// @TODO: should statically initialize these for optimal thread safety +static uint8 default_length[288], default_distance[32]; +static void init_defaults(void) +{ + int i; // use <= to match clearly with spec + for (i = 0; i <= 143; ++i) + default_length[i] = 8; + for (; i <= 255; ++i) + default_length[i] = 9; + for (; i <= 279; ++i) + default_length[i] = 7; + for (; i <= 287; ++i) + default_length[i] = 8; + + for (i = 0; i <= 31; ++i) + default_distance[i] = 5; +} + +int stbi_png_partial; // a quick hack to only allow decoding some of a PNG... I should implement + // real streaming support instead +static int parse_zlib(zbuf* a, int parse_header) +{ + int final, type; + if (parse_header) + if (!parse_zlib_header(a)) + return 0; + a->num_bits = 0; + a->code_buffer = 0; + do + { + final = zreceive(a, 1); + type = zreceive(a, 2); + if (type == 0) + { + if (!parse_uncompressed_block(a)) + return 0; + } + else if (type == 3) + { + return 0; + } + else + { + if (type == 1) + { + // use fixed code lengths + if (!default_distance[31]) + init_defaults(); + if (!zbuild_huffman(&a->z_length, default_length, 288)) + return 0; + if (!zbuild_huffman(&a->z_distance, default_distance, 32)) + return 0; + } + else + { + if (!compute_huffman_codes(a)) + return 0; + } + if (!parse_huffman_block(a)) + return 0; + } + if (stbi_png_partial && a->zout - a->zout_start > 65536) + break; + } while (!final); + return 1; +} + +static int do_zlib(zbuf* a, char* obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return parse_zlib(a, parse_header); +} + +char* stbi_zlib_decode_malloc_guesssize(const char* buffer, int len, int initial_size, int* outlen) +{ + zbuf a; + char* p = (char*)malloc(initial_size); + if (p == NULL) + return NULL; + a.zbuffer = (uint8*)buffer; + a.zbuffer_end = (uint8*)buffer + len; + if (do_zlib(&a, p, initial_size, 1, 1)) + { + if (outlen) + *outlen = (int)(a.zout - a.zout_start); + return a.zout_start; + } + else + { + free(a.zout_start); + return NULL; + } +} + +char* stbi_zlib_decode_malloc(char const* buffer, int len, int* outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +char* stbi_zlib_decode_malloc_guesssize_headerflag(const char* buffer, int len, int initial_size, + int* outlen, int parse_header) +{ + zbuf a; + char* p = (char*)malloc(initial_size); + if (p == NULL) + return NULL; + a.zbuffer = (uint8*)buffer; + a.zbuffer_end = (uint8*)buffer + len; + if (do_zlib(&a, p, initial_size, 1, parse_header)) + { + if (outlen) + *outlen = (int)(a.zout - a.zout_start); + return a.zout_start; + } + else + { + free(a.zout_start); + return NULL; + } +} + +int stbi_zlib_decode_buffer(char* obuffer, int olen, char const* ibuffer, int ilen) +{ + zbuf a; + a.zbuffer = (uint8*)ibuffer; + a.zbuffer_end = (uint8*)ibuffer + ilen; + if (do_zlib(&a, obuffer, olen, 0, 1)) + return (int)(a.zout - a.zout_start); + else + return -1; +} + +char* stbi_zlib_decode_noheader_malloc(char const* buffer, int len, int* outlen) +{ + zbuf a; + char* p = (char*)malloc(16384); + if (p == NULL) + return NULL; + a.zbuffer = (uint8*)buffer; + a.zbuffer_end = (uint8*)buffer + len; + if (do_zlib(&a, p, 16384, 1, 0)) + { + if (outlen) + *outlen = (int)(a.zout - a.zout_start); + return a.zout_start; + } + else + { + free(a.zout_start); + return NULL; + } +} + +int stbi_zlib_decode_noheader_buffer(char* obuffer, int olen, const char* ibuffer, int ilen) +{ + zbuf a; + a.zbuffer = (uint8*)ibuffer; + a.zbuffer_end = (uint8*)ibuffer + ilen; + if (do_zlib(&a, obuffer, olen, 0, 0)) + return (int)(a.zout - a.zout_start); + else + return -1; +} + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +typedef struct +{ + uint32 length; + uint32 type; +} chunk; + +#define PNG_TYPE(a, b, c, d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) + +static chunk get_chunk_header(stbi* s) +{ + chunk c; + c.length = get32(s); + c.type = get32(s); + return c; +} + +static int check_png_header(stbi* s) +{ + static uint8 png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; + int i; + for (i = 0; i < 8; ++i) + if (get8u(s) != png_sig[i]) + return e("bad png sig", "Not a PNG"); + return 1; +} + +typedef struct +{ + stbi* s; + uint8 *idata, *expanded, *out; +} png; + +enum +{ + F_none = 0, + F_sub = 1, + F_up = 2, + F_avg = 3, + F_paeth = 4, + F_avg_first, + F_paeth_first +}; + +static uint8 first_row_filter[5] = {F_none, F_sub, F_none, F_avg_first, F_paeth_first}; + +static int paeth(int a, int b, int c) +{ + int p = a + b - c; + int pa = abs(p - a); + int pb = abs(p - b); + int pc = abs(p - c); + if (pa <= pb && pa <= pc) + return a; + if (pb <= pc) + return b; + return c; +} + +// initialize the png data from post-deflated data +static int create_png_image_raw(png* a, uint8* raw, uint32 raw_len, int out_n, uint32 x, uint32 y) +{ + stbi* s = a->s; + uint32 i, j, stride = x * out_n; + int k; + int img_n = s->img_n; // copy it into a local for later + assert(out_n == s->img_n || out_n == s->img_n + 1); + if (stbi_png_partial) + y = 1; + a->out = (uint8*)malloc(x * y * out_n); + if (!a->out) + return e("outofmem", "Out of memory"); + if (!stbi_png_partial) + { + if (s->img_x == x && s->img_y == y) + { + if (raw_len != (img_n * x + 1) * y) + return e("not enough pixels", "Corrupt PNG"); + } + else + { // interlaced: + if (raw_len < (img_n * x + 1) * y) + return e("not enough pixels", "Corrupt PNG"); + } + } + for (j = 0; j < y; ++j) + { + uint8* cur = a->out + stride * j; + uint8* prior = cur - stride; + int filter = *raw++; + if (filter > 4) + return e("invalid filter", "Corrupt PNG"); + // if first row, use special filter that doesn't sample previous row + if (j == 0) + filter = first_row_filter[filter]; + // handle first pixel explicitly + for (k = 0; k < img_n; ++k) + { + switch (filter) + { + case F_none: + cur[k] = raw[k]; + break; + case F_sub: + cur[k] = raw[k]; + break; + case F_up: + cur[k] = raw[k] + prior[k]; + break; + case F_avg: + cur[k] = raw[k] + (prior[k] >> 1); + break; + case F_paeth: + cur[k] = (uint8)(raw[k] + paeth(0, prior[k], 0)); + break; + case F_avg_first: + cur[k] = raw[k]; + break; + case F_paeth_first: + cur[k] = raw[k]; + break; + } + } + if (img_n != out_n) + cur[img_n] = 255; + raw += img_n; + cur += out_n; + prior += out_n; + // this is a little gross, so that we don't switch per-pixel or per-component + if (img_n == out_n) + { +#define CASE(f) \ + case f: \ + for (i = x - 1; i >= 1; --i, raw += img_n, cur += img_n, prior += img_n) \ + for (k = 0; k < img_n; ++k) + switch (filter) + { + CASE(F_none) cur[k] = raw[k]; + break; + CASE(F_sub) cur[k] = raw[k] + cur[k - img_n]; + break; + CASE(F_up) cur[k] = raw[k] + prior[k]; + break; + CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k - img_n]) >> 1); + break; + CASE(F_paeth) + cur[k] = (uint8)(raw[k] + paeth(cur[k - img_n], prior[k], prior[k - img_n])); + break; + CASE(F_avg_first) cur[k] = raw[k] + (cur[k - img_n] >> 1); + break; + CASE(F_paeth_first) cur[k] = (uint8)(raw[k] + paeth(cur[k - img_n], 0, 0)); + break; + } +#undef CASE + } + else + { + assert(img_n + 1 == out_n); +#define CASE(f) \ + case f: \ + for (i = x - 1; i >= 1; --i, cur[img_n] = 255, raw += img_n, cur += out_n, prior += out_n) \ + for (k = 0; k < img_n; ++k) + switch (filter) + { + CASE(F_none) cur[k] = raw[k]; + break; + CASE(F_sub) cur[k] = raw[k] + cur[k - out_n]; + break; + CASE(F_up) cur[k] = raw[k] + prior[k]; + break; + CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k - out_n]) >> 1); + break; + CASE(F_paeth) + cur[k] = (uint8)(raw[k] + paeth(cur[k - out_n], prior[k], prior[k - out_n])); + break; + CASE(F_avg_first) cur[k] = raw[k] + (cur[k - out_n] >> 1); + break; + CASE(F_paeth_first) cur[k] = (uint8)(raw[k] + paeth(cur[k - out_n], 0, 0)); + break; + } +#undef CASE + } + } + return 1; +} + +static int create_png_image(png* a, uint8* raw, uint32 raw_len, int out_n, int interlaced) +{ + uint8* final; + int p; + int save; + if (!interlaced) + return create_png_image_raw(a, raw, raw_len, out_n, a->s->img_x, a->s->img_y); + save = stbi_png_partial; + stbi_png_partial = 0; + + // de-interlacing + final = (uint8*)malloc(a->s->img_x * a->s->img_y * out_n); + for (p = 0; p < 7; ++p) + { + int xorig[] = {0, 4, 0, 2, 0, 1, 0}; + int yorig[] = {0, 0, 4, 0, 2, 0, 1}; + int xspc[] = {8, 8, 4, 4, 2, 2, 1}; + int yspc[] = {8, 8, 8, 4, 4, 2, 2}; + int i, j, x, y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p] - 1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p] - 1) / yspc[p]; + if (x && y) + { + if (!create_png_image_raw(a, raw, raw_len, out_n, x, y)) + { + free(final); + return 0; + } + for (j = 0; j < y; ++j) + for (i = 0; i < x; ++i) + memcpy(final + (j * yspc[p] + yorig[p]) * a->s->img_x * out_n + + (i * xspc[p] + xorig[p]) * out_n, + a->out + (j * x + i) * out_n, out_n); + free(a->out); + raw += (x * out_n + 1) * y; + raw_len -= (x * out_n + 1) * y; + } + } + a->out = final; + + stbi_png_partial = save; + return 1; +} + +static int compute_transparency(png* z, uint8 tc[3], int out_n) +{ + stbi* s = z->s; + uint32 i, pixel_count = s->img_x * s->img_y; + uint8* p = z->out; + + // compute mColor-based transparency, assuming we've + // already got 255 as the alpha value in the output + assert(out_n == 2 || out_n == 4); + + if (out_n == 2) + { + for (i = 0; i < pixel_count; ++i) + { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } + else + { + for (i = 0; i < pixel_count; ++i) + { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int expand_palette(png* a, uint8* palette, int len, int pal_img_n) +{ + uint32 i, pixel_count = a->s->img_x * a->s->img_y; + uint8 *p, *temp_out, *orig = a->out; + + p = (uint8*)malloc(pixel_count * pal_img_n); + if (p == NULL) + return e("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) + { + for (i = 0; i < pixel_count; ++i) + { + int n = orig[i] * 4; + p[0] = palette[n]; + p[1] = palette[n + 1]; + p[2] = palette[n + 2]; + p += 3; + } + } + else + { + for (i = 0; i < pixel_count; ++i) + { + int n = orig[i] * 4; + p[0] = palette[n]; + p[1] = palette[n + 1]; + p[2] = palette[n + 2]; + p[3] = palette[n + 3]; + p += 4; + } + } + free(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi_unpremultiply_on_load = 0; +static int stbi_de_iphone_flag = 0; + +void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi_unpremultiply_on_load = flag_true_if_should_unpremultiply; +} +void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi_de_iphone_flag = flag_true_if_should_convert; +} + +static void stbi_de_iphone(png* z) +{ + stbi* s = z->s; + uint32 i, pixel_count = s->img_x * s->img_y; + uint8* p = z->out; + + if (s->img_out_n == 3) + { // convert bgr to rgb + for (i = 0; i < pixel_count; ++i) + { + uint8 t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } + else + { + assert(s->img_out_n == 4); + if (stbi_unpremultiply_on_load) + { + // convert bgr to rgb and unpremultiply + for (i = 0; i < pixel_count; ++i) + { + uint8 a = p[3]; + uint8 t = p[0]; + if (a) + { + p[0] = p[2] * 255 / a; + p[1] = p[1] * 255 / a; + p[2] = t * 255 / a; + } + else + { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } + else + { + // convert bgr to rgb + for (i = 0; i < pixel_count; ++i) + { + uint8 t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +static int parse_png_file(png* z, int scan, int req_comp) +{ + uint8 palette[1024], pal_img_n = 0; + uint8 has_trans = 0, tc[3]; + uint32 ioff = 0, idata_limit = 0, i, pal_len = 0; + int first = 1, k, interlace = 0, iphone = 0; + stbi* s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!check_png_header(s)) + return 0; + + if (scan == SCAN_type) + return 1; + + for (;;) + { + chunk c = get_chunk_header(s); + switch (c.type) + { + case PNG_TYPE('C', 'g', 'B', 'I'): + iphone = stbi_de_iphone_flag; + skip(s, c.length); + break; + case PNG_TYPE('I', 'H', 'D', 'R'): + { + int depth, color, comp, filter; + if (!first) + return e("multiple IHDR", "Corrupt PNG"); + first = 0; + if (c.length != 13) + return e("bad IHDR len", "Corrupt PNG"); + s->img_x = get32(s); + if (s->img_x > (1 << 24)) + return e("too large", "Very large image (corrupt?)"); + s->img_y = get32(s); + if (s->img_y > (1 << 24)) + return e("too large", "Very large image (corrupt?)"); + depth = get8(s); + if (depth != 8) + return e("8bit only", "PNG not supported: 8-bit only"); + color = get8(s); + if (color > 6) + return e("bad ctype", "Corrupt PNG"); + if (color == 3) + pal_img_n = 3; + else if (color & 1) + return e("bad ctype", "Corrupt PNG"); + comp = get8(s); + if (comp) + return e("bad comp method", "Corrupt PNG"); + filter = get8(s); + if (filter) + return e("bad filter method", "Corrupt PNG"); + interlace = get8(s); + if (interlace > 1) + return e("bad interlace method", "Corrupt PNG"); + if (!s->img_x || !s->img_y) + return e("0-pixel image", "Corrupt PNG"); + if (!pal_img_n) + { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) + return e("too large", "Image too large to decode"); + if (scan == SCAN_header) + return 1; + } + else + { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) + return e("too large", "Corrupt PNG"); + // if SCAN_header, have to scan to see if we have a tRNS + } + break; + } + + case PNG_TYPE('P', 'L', 'T', 'E'): + { + if (first) + return e("first not IHDR", "Corrupt PNG"); + if (c.length > 256 * 3) + return e("invalid PLTE", "Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) + return e("invalid PLTE", "Corrupt PNG"); + for (i = 0; i < pal_len; ++i) + { + palette[i * 4 + 0] = get8u(s); + palette[i * 4 + 1] = get8u(s); + palette[i * 4 + 2] = get8u(s); + palette[i * 4 + 3] = 255; + } + break; + } + + case PNG_TYPE('t', 'R', 'N', 'S'): + { + if (first) + return e("first not IHDR", "Corrupt PNG"); + if (z->idata) + return e("tRNS after IDAT", "Corrupt PNG"); + if (pal_img_n) + { + if (scan == SCAN_header) + { + s->img_n = 4; + return 1; + } + if (pal_len == 0) + return e("tRNS before PLTE", "Corrupt PNG"); + if (c.length > pal_len) + return e("bad tRNS len", "Corrupt PNG"); + pal_img_n = 4; + for (i = 0; i < c.length; ++i) + palette[i * 4 + 3] = get8u(s); + } + else + { + if (!(s->img_n & 1)) + return e("tRNS with alpha", "Corrupt PNG"); + if (c.length != (uint32)s->img_n * 2) + return e("bad tRNS len", "Corrupt PNG"); + has_trans = 1; + for (k = 0; k < s->img_n; ++k) + tc[k] = (uint8)get16(s); // non 8-bit images will be larger + } + break; + } + + case PNG_TYPE('I', 'D', 'A', 'T'): + { + if (first) + return e("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) + return e("no PLTE", "Corrupt PNG"); + if (scan == SCAN_header) + { + s->img_n = pal_img_n; + return 1; + } + if (ioff + c.length > idata_limit) + { + uint8* p; + if (idata_limit == 0) + idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + p = (uint8*)realloc(z->idata, idata_limit); + if (p == NULL) + return e("outofmem", "Out of memory"); + z->idata = p; + } + if (!getn(s, z->idata + ioff, c.length)) + return e("outofdata", "Corrupt PNG"); + ioff += c.length; + break; + } + + case PNG_TYPE('I', 'E', 'N', 'D'): + { + uint32 raw_len; + if (first) + return e("first not IHDR", "Corrupt PNG"); + if (scan != SCAN_load) + return 1; + if (z->idata == NULL) + return e("no IDAT", "Corrupt PNG"); + z->expanded = (uint8*)stbi_zlib_decode_malloc_guesssize_headerflag( + (char*)z->idata, ioff, 16384, (int*)&raw_len, !iphone); + if (z->expanded == NULL) + return 0; // zlib should set error + free(z->idata); + z->idata = NULL; + if ((req_comp == s->img_n + 1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n + 1; + else + s->img_out_n = s->img_n; + if (!create_png_image(z, z->expanded, raw_len, s->img_out_n, interlace)) + return 0; + if (has_trans) + if (!compute_transparency(z, tc, s->img_out_n)) + return 0; + if (iphone && s->img_out_n > 2) + stbi_de_iphone(z); + if (pal_img_n) + { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) + s->img_out_n = req_comp; + if (!expand_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } + free(z->expanded); + z->expanded = NULL; + return 1; + } + + default: + // if critical, fail + if (first) + return e("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) + { +#ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX chunk not known"; + invalid_chunk[0] = (uint8)(c.type >> 24); + invalid_chunk[1] = (uint8)(c.type >> 16); + invalid_chunk[2] = (uint8)(c.type >> 8); + invalid_chunk[3] = (uint8)(c.type >> 0); +#endif + return e(invalid_chunk, "PNG not supported: unknown chunk type"); + } + skip(s, c.length); + break; + } + // end of chunk, read and skip CRC + get32(s); + } +} + +static unsigned char* do_png(png* p, int* x, int* y, int* n, int req_comp) +{ + unsigned char* result = NULL; + if (req_comp < 0 || req_comp > 4) + return epuc("bad req_comp", "Internal error"); + if (parse_png_file(p, SCAN_load, req_comp)) + { + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) + { + result = convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) + return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) + *n = p->s->img_n; + } + free(p->out); + p->out = NULL; + free(p->expanded); + p->expanded = NULL; + free(p->idata); + p->idata = NULL; + + return result; +} + +static unsigned char* stbi_png_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + png p; + p.s = s; + return do_png(&p, x, y, comp, req_comp); +} + +static int stbi_png_test(stbi* s) +{ + int r; + r = check_png_header(s); + stbi_rewind(s); + return r; +} + +static int stbi_png_info_raw(png* p, int* x, int* y, int* comp) +{ + if (!parse_png_file(p, SCAN_header, 0)) + { + stbi_rewind(p->s); + return 0; + } + if (x) + *x = p->s->img_x; + if (y) + *y = p->s->img_y; + if (comp) + *comp = p->s->img_n; + return 1; +} + +static int stbi_png_info(stbi* s, int* x, int* y, int* comp) +{ + png p; + p.s = s; + return stbi_png_info_raw(&p, x, y, comp); +} + +// Microsoft/Windows BMP image + +static int bmp_test(stbi* s) +{ + int sz; + if (get8(s) != 'B') + return 0; + if (get8(s) != 'M') + return 0; + get32le(s); // discard filesize + get16le(s); // discard reserved + get16le(s); // discard reserved + get32le(s); // discard data offset + sz = get32le(s); + if (sz == 12 || sz == 40 || sz == 56 || sz == 108) + return 1; + return 0; +} + +static int stbi_bmp_test(stbi* s) +{ + int r = bmp_test(s); + stbi_rewind(s); + return r; +} + +// returns 0..31 for the highest set bit +static int high_bit(unsigned int z) +{ + int n = 0; + if (z == 0) + return -1; + if (z >= 0x10000) + n += 16, z >>= 16; + if (z >= 0x00100) + n += 8, z >>= 8; + if (z >= 0x00010) + n += 4, z >>= 4; + if (z >= 0x00004) + n += 2, z >>= 2; + if (z >= 0x00002) + n += 1, z >>= 1; + return n; +} + +static int bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +static int shiftsigned(int v, int shift, int bits) +{ + int result; + int z = 0; + + if (shift < 0) + v <<= -shift; + else + v >>= shift; + result = v; + + z = bits; + while (z < 8) + { + result += v >> z; + z += bits; + } + return result; +} + +static stbi_uc* bmp_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + uint8* out; + unsigned int mr = 0, mg = 0, mb = 0, ma = 0, fake_a = 0; + stbi_uc pal[256][4]; + int psize = 0, i, j, compress = 0, width; + int bpp, flip_vertically, pad, target, offset, hsz; + if (get8(s) != 'B' || get8(s) != 'M') + return epuc("not BMP", "Corrupt BMP"); + get32le(s); // discard filesize + get16le(s); // discard reserved + get16le(s); // discard reserved + offset = get32le(s); + hsz = get32le(s); + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) + return epuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) + { + s->img_x = get16le(s); + s->img_y = get16le(s); + } + else + { + s->img_x = get32le(s); + s->img_y = get32le(s); + } + if (get16le(s) != 1) + return epuc("bad BMP", "bad BMP"); + bpp = get16le(s); + if (bpp == 1) + return epuc("monochrome", "BMP type not supported: 1-bit"); + flip_vertically = ((int)s->img_y) > 0; + s->img_y = abs((int)s->img_y); + if (hsz == 12) + { + if (bpp < 24) + psize = (offset - 14 - 24) / 3; + } + else + { + compress = get32le(s); + if (compress == 1 || compress == 2) + return epuc("BMP RLE", "BMP type not supported: RLE"); + get32le(s); // discard sizeof + get32le(s); // discard hres + get32le(s); // discard vres + get32le(s); // discard colorsused + get32le(s); // discard max important + if (hsz == 40 || hsz == 56) + { + if (hsz == 56) + { + get32le(s); + get32le(s); + get32le(s); + get32le(s); + } + if (bpp == 16 || bpp == 32) + { + mr = mg = mb = 0; + if (compress == 0) + { + if (bpp == 32) + { + mr = 0xffu << 16; + mg = 0xffu << 8; + mb = 0xffu << 0; + ma = 0xffu << 24; + fake_a = 1; // @TODO: check for cases like alpha value is all 0 and switch + // it to 255 + } + else + { + mr = 31u << 10; + mg = 31u << 5; + mb = 31u << 0; + } + } + else if (compress == 3) + { + mr = get32le(s); + mg = get32le(s); + mb = get32le(s); + // not documented, but generated by photoshop and handled by mspaint + if (mr == mg && mg == mb) + { + // ?!?!? + return epuc("bad BMP", "bad BMP"); + } + } + else + return epuc("bad BMP", "bad BMP"); + } + } + else + { + assert(hsz == 108); + mr = get32le(s); + mg = get32le(s); + mb = get32le(s); + ma = get32le(s); + get32le(s); // discard mColor space + for (i = 0; i < 12; ++i) + get32le(s); // discard mColor space parameters + } + if (bpp < 16) + psize = (offset - 14 - hsz) >> 2; + } + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + out = (stbi_uc*)malloc(target * s->img_x * s->img_y); + if (!out) + return epuc("outofmem", "Out of memory"); + if (bpp < 16) + { + int z = 0; + if (psize == 0 || psize > 256) + { + free(out); + return epuc("invalid", "Corrupt BMP"); + } + for (i = 0; i < psize; ++i) + { + pal[i][2] = get8u(s); + pal[i][1] = get8u(s); + pal[i][0] = get8u(s); + if (hsz != 12) + get8(s); + pal[i][3] = 255; + } + skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4)); + if (bpp == 4) + width = (s->img_x + 1) >> 1; + else if (bpp == 8) + width = s->img_x; + else + { + free(out); + return epuc("bad bpp", "Corrupt BMP"); + } + pad = (-width) & 3; + for (j = 0; j < (int)s->img_y; ++j) + { + for (i = 0; i < (int)s->img_x; i += 2) + { + int v = get8(s), v2 = 0; + if (bpp == 4) + { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) + out[z++] = 255; + if (i + 1 == (int)s->img_x) + break; + v = (bpp == 8) ? get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) + out[z++] = 255; + } + skip(s, pad); + } + } + else + { + int rshift = 0, gshift = 0, bshift = 0, ashift = 0, rcount = 0, gcount = 0, bcount = 0, + acount = 0; + int z = 0; + int easy = 0; + skip(s, offset - 14 - hsz); + if (bpp == 24) + width = 3 * s->img_x; + else if (bpp == 16) + width = 2 * s->img_x; + else /* bpp = 32 and pad = 0 */ + width = 0; + pad = (-width) & 3; + if (bpp == 24) + { + easy = 1; + } + else if (bpp == 32) + { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) + { + if (!mr || !mg || !mb) + { + free(out); + return epuc("bad masks", "Corrupt BMP"); + } + // right shift amt to put high bit in position #7 + rshift = high_bit(mr) - 7; + rcount = bitcount(mr); + gshift = high_bit(mg) - 7; + gcount = bitcount(mr); + bshift = high_bit(mb) - 7; + bcount = bitcount(mr); + ashift = high_bit(ma) - 7; + acount = bitcount(mr); + } + for (j = 0; j < (int)s->img_y; ++j) + { + if (easy) + { + for (i = 0; i < (int)s->img_x; ++i) + { + int a; + out[z + 2] = get8u(s); + out[z + 1] = get8u(s); + out[z + 0] = get8u(s); + z += 3; + a = (easy == 2 ? get8(s) : 255); + if (target == 4) + out[z++] = (uint8)a; + } + } + else + { + for (i = 0; i < (int)s->img_x; ++i) + { + uint32 v = (bpp == 16 ? get16le(s) : get32le(s)); + int a; + out[z++] = (uint8)shiftsigned(v & mr, rshift, rcount); + out[z++] = (uint8)shiftsigned(v & mg, gshift, gcount); + out[z++] = (uint8)shiftsigned(v & mb, bshift, bcount); + a = (ma ? shiftsigned(v & ma, ashift, acount) : 255); + if (target == 4) + out[z++] = (uint8)a; + } + } + skip(s, pad); + } + } + if (flip_vertically) + { + stbi_uc t; + for (j = 0; j < (int)s->img_y >> 1; ++j) + { + stbi_uc* p1 = out + j * s->img_x * target; + stbi_uc* p2 = out + (s->img_y - 1 - j) * s->img_x * target; + for (i = 0; i < (int)s->img_x * target; ++i) + { + t = p1[i], p1[i] = p2[i], p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) + { + out = convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) + return out; // convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) + *comp = s->img_n; + return out; +} + +static stbi_uc* stbi_bmp_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + return bmp_load(s, x, y, comp, req_comp); +} + +// Targa Truevision - TGA +// by Jonathan Dummer + +static int tga_info(stbi* s, int* x, int* y, int* comp) +{ + int tga_w, tga_h, tga_comp; + int sz; + get8u(s); // discard Offset + sz = get8u(s); // mColor type + if (sz > 1) + { + stbi_rewind(s); + return 0; // only RGB or indexed allowed + } + sz = get8u(s); // image type + // only RGB or grey allowed, +/- RLE + if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) + return 0; + skip(s, 9); + tga_w = get16le(s); + if (tga_w < 1) + { + stbi_rewind(s); + return 0; // test mWidth + } + tga_h = get16le(s); + if (tga_h < 1) + { + stbi_rewind(s); + return 0; // test mHeight + } + sz = get8(s); // bits per pixel + // only RGB or RGBA or grey allowed + if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) + { + stbi_rewind(s); + return 0; + } + tga_comp = sz; + if (x) + *x = tga_w; + if (y) + *y = tga_h; + if (comp) + *comp = tga_comp / 8; + return 1; // seems to have passed everything +} + +int stbi_tga_info(stbi* s, int* x, int* y, int* comp) +{ + return tga_info(s, x, y, comp); +} + +static int tga_test(stbi* s) +{ + int sz; + get8u(s); // discard Offset + sz = get8u(s); // mColor type + if (sz > 1) + return 0; // only RGB or indexed allowed + sz = get8u(s); // image type + if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) + return 0; // only RGB or grey allowed, +/- RLE + get16(s); // discard palette start + get16(s); // discard palette length + get8(s); // discard bits per palette mColor entry + get16(s); // discard x origin + get16(s); // discard y origin + if (get16(s) < 1) + return 0; // test mWidth + if (get16(s) < 1) + return 0; // test mHeight + sz = get8(s); // bits per pixel + if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) + return 0; // only RGB or RGBA or grey allowed + return 1; // seems to have passed everything +} + +static int stbi_tga_test(stbi* s) +{ + int res = tga_test(s); + stbi_rewind(s); + return res; +} + +static stbi_uc* tga_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + // read in the TGA header stuff + int tga_offset = get8u(s); + int tga_indexed = get8u(s); + int tga_image_type = get8u(s); + int tga_is_RLE = 0; + int tga_palette_start = get16le(s); + int tga_palette_len = get16le(s); + int tga_palette_bits = get8u(s); + int tga_x_origin = get16le(s); + int tga_y_origin = get16le(s); + int tga_width = get16le(s); + int tga_height = get16le(s); + int tga_bits_per_pixel = get8u(s); + int tga_inverted = get8u(s); + // image data + unsigned char* tga_data; + unsigned char* tga_palette = NULL; + int i, j; + unsigned char raw_data[4]; + unsigned char trans_data[4]; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + + // do a tiny bit of precessing + if (tga_image_type >= 8) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + /* int tga_alpha_bits = tga_inverted & 15; */ + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // error check + if ( //(tga_indexed) || + (tga_width < 1) || (tga_height < 1) || (tga_image_type < 1) || (tga_image_type > 3) || + ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) && (tga_bits_per_pixel != 24) && + (tga_bits_per_pixel != 32))) + { + return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA + } + + // If I'm paletted, then I'll use the number of bits from the palette + if (tga_indexed) + { + tga_bits_per_pixel = tga_palette_bits; + } + + // tga info + *x = tga_width; + *y = tga_height; + if ((req_comp < 1) || (req_comp > 4)) + { + // just use whatever the file was + req_comp = tga_bits_per_pixel / 8; + *comp = req_comp; + } + else + { + // force a new number of components + *comp = tga_bits_per_pixel / 8; + } + tga_data = (unsigned char*)malloc(tga_width * tga_height * req_comp); + if (!tga_data) + return epuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + skip(s, tga_offset); + // do I need to loadSound a palette? + if (tga_indexed) + { + // any data to skip? (offset usually = 0) + skip(s, tga_palette_start); + // loadSound the palette + tga_palette = (unsigned char*)malloc(tga_palette_len * tga_palette_bits / 8); + if (!tga_palette) + return epuc("outofmem", "Out of memory"); + if (!getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8)) + { + free(tga_data); + free(tga_palette); + return epuc("bad palette", "Corrupt TGA"); + } + } + // loadSound the data + trans_data[0] = trans_data[1] = trans_data[2] = trans_data[3] = 0; + for (i = 0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE chunk? + if (tga_is_RLE) + { + if (RLE_count == 0) + { + // yep, get the next byte as a RLE command + int RLE_cmd = get8u(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } + else if (!RLE_repeating) + { + read_next_pixel = 1; + } + } + else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if (read_next_pixel) + { + // loadSound however much data we did have + if (tga_indexed) + { + // read in 1 byte, then perform the lookup + int pal_idx = get8u(s); + if (pal_idx >= tga_palette_len) + { + // invalid mIndex + pal_idx = 0; + } + pal_idx *= tga_bits_per_pixel / 8; + for (j = 0; j * 8 < tga_bits_per_pixel; ++j) + { + raw_data[j] = tga_palette[pal_idx + j]; + } + } + else + { + // read in the data raw + for (j = 0; j * 8 < tga_bits_per_pixel; ++j) + { + raw_data[j] = get8u(s); + } + } + // convert raw to the intermediate format + switch (tga_bits_per_pixel) + { + case 8: + // Luminous => RGBA + trans_data[0] = raw_data[0]; + trans_data[1] = raw_data[0]; + trans_data[2] = raw_data[0]; + trans_data[3] = 255; + break; + case 16: + // Luminous,Alpha => RGBA + trans_data[0] = raw_data[0]; + trans_data[1] = raw_data[0]; + trans_data[2] = raw_data[0]; + trans_data[3] = raw_data[1]; + break; + case 24: + // BGR => RGBA + trans_data[0] = raw_data[2]; + trans_data[1] = raw_data[1]; + trans_data[2] = raw_data[0]; + trans_data[3] = 255; + break; + case 32: + // BGRA => RGBA + trans_data[0] = raw_data[2]; + trans_data[1] = raw_data[1]; + trans_data[2] = raw_data[0]; + trans_data[3] = raw_data[3]; + break; + } + // release the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + // convert to final format + switch (req_comp) + { + case 1: + // RGBA => Luminance + tga_data[i * req_comp + 0] = compute_y(trans_data[0], trans_data[1], trans_data[2]); + break; + case 2: + // RGBA => Luminance,Alpha + tga_data[i * req_comp + 0] = compute_y(trans_data[0], trans_data[1], trans_data[2]); + tga_data[i * req_comp + 1] = trans_data[3]; + break; + case 3: + // RGBA => RGB + tga_data[i * req_comp + 0] = trans_data[0]; + tga_data[i * req_comp + 1] = trans_data[1]; + tga_data[i * req_comp + 2] = trans_data[2]; + break; + case 4: + // RGBA => RGBA + tga_data[i * req_comp + 0] = trans_data[0]; + tga_data[i * req_comp + 1] = trans_data[1]; + tga_data[i * req_comp + 2] = trans_data[2]; + tga_data[i * req_comp + 3] = trans_data[3]; + break; + } + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if (tga_inverted) + { + for (j = 0; j * 2 < tga_height; ++j) + { + int index1 = j * tga_width * req_comp; + int index2 = (tga_height - 1 - j) * tga_width * req_comp; + for (i = tga_width * req_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // release my palette, if I had one + if (tga_palette != NULL) + { + free(tga_palette); + } + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = tga_x_origin = tga_y_origin = 0; + // OK, done + return tga_data; +} + +static stbi_uc* stbi_tga_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + return tga_load(s, x, y, comp, req_comp); +} + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +static int psd_test(stbi* s) +{ + if (get32(s) != 0x38425053) + return 0; // "8BPS" + else + return 1; +} + +static int stbi_psd_test(stbi* s) +{ + int r = psd_test(s); + stbi_rewind(s); + return r; +} + +static stbi_uc* psd_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + int pixelCount; + int channelCount, compression; + int channel, i, count, len; + int w, h; + uint8* out; + + // Check identifier + if (get32(s) != 0x38425053) // "8BPS" + return epuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (get16(s) != 1) + return epuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + skip(s, 6); + + // Read the number of channels (R, G, B, A, etc). + channelCount = get16(s); + if (channelCount < 0 || channelCount > 16) + return epuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = get32(s); + w = get32(s); + + // Make sure the depth is 8 bits. + if (get16(s) != 8) + return epuc("unsupported bit depth", "PSD bit depth is not 8 bit"); + + // Make sure the mColor mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed mColor + // 3: RGB mColor + // 4: CMYK mColor + // 7: Multichannel + // 8: Duotone + // 9: Lab mColor + if (get16(s) != 3) + return epuc("wrong mColor format", "PSD is not in RGB mColor format"); + + // Skip the Mode Data. (It's the palette for indexed mColor; other info for other modes.) + skip(s, get32(s)); + + // Skip the image resources. (resolution, pen tool paths, etc) + skip(s, get32(s)); + + // Skip the reserved data. + skip(s, get32(s)); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = get16(s); + if (compression > 1) + return epuc("bad compression", "PSD has an unknown compression format"); + + // Create the destination image. + out = (stbi_uc*)malloc(4 * w * h); + if (!out) + return epuc("outofmem", "Out of memory"); + pixelCount = w * h; + + // Initialize the data to zero. + // memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) + { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data, + // which we're going to just skip. + skip(s, h * channelCount * 2); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) + { + uint8* p; + + p = out + channel; + if (channel >= channelCount) + { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++) + *p = (channel == 3 ? 255 : 0), p += 4; + } + else + { + // Read the RLE data. + count = 0; + while (count < pixelCount) + { + len = get8(s); + if (len == 128) + { + // No-op. + } + else if (len < 128) + { + // Copy next len+1 bytes literally. + len++; + count += len; + while (len) + { + *p = get8u(s); + p += 4; + len--; + } + } + else if (len > 128) + { + uint8 val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len ^= 0x0FF; + len += 2; + val = get8u(s); + count += len; + while (len) + { + *p = val; + p += 4; + len--; + } + } + } + } + } + } + else + { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) + { + uint8* p; + + p = out + channel; + if (channel > channelCount) + { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++) + *p = channel == 3 ? 255 : 0, p += 4; + } + else + { + // Read the data. + for (i = 0; i < pixelCount; i++) + *p = get8u(s), p += 4; + } + } + } + + if (req_comp && req_comp != 4) + { + out = convert_format(out, 4, req_comp, w, h); + if (out == NULL) + return out; // convert_format frees input on failure + } + + if (comp) + *comp = channelCount; + *y = h; + *x = w; + + return out; +} + +static stbi_uc* stbi_psd_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + return psd_load(s, x, y, comp, req_comp); +} + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +static int pic_is4(stbi* s, const char* str) +{ + int i; + for (i = 0; i < 4; ++i) + if (get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int pic_test(stbi* s) +{ + int i; + + if (!pic_is4(s, "\x53\x80\xF6\x34")) + return 0; + + for (i = 0; i < 84; ++i) + get8(s); + + if (!pic_is4(s, "PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size, type, channel; +} pic_packet_t; + +static stbi_uc* pic_readval(stbi* s, int channel, stbi_uc* dest) +{ + int mask = 0x80, i; + + for (i = 0; i < 4; ++i, mask >>= 1) + { + if (channel & mask) + { + if (at_eof(s)) + return epuc("bad file", "PIC file too short"); + dest[i] = get8u(s); + } + } + + return dest; +} + +static void pic_copyval(int channel, stbi_uc* dest, const stbi_uc* src) +{ + int mask = 0x80, i; + + for (i = 0; i < 4; ++i, mask >>= 1) + if (channel & mask) + dest[i] = src[i]; +} + +static stbi_uc* pic_load2(stbi* s, int width, int height, int* comp, stbi_uc* result) +{ + int act_comp = 0, num_packets = 0, y, chained; + pic_packet_t packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do + { + pic_packet_t* packet; + + if (num_packets == sizeof(packets) / sizeof(packets[0])) + return epuc("bad format", "too many packets"); + + packet = &packets[num_packets++]; + + chained = get8(s); + packet->size = get8u(s); + packet->type = get8u(s); + packet->channel = get8u(s); + + act_comp |= packet->channel; + + if (at_eof(s)) + return epuc("bad file", "file too short (reading packets)"); + if (packet->size != 8) + return epuc("bad format", "packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for (y = 0; y < height; ++y) + { + int packet_idx; + + for (packet_idx = 0; packet_idx < num_packets; ++packet_idx) + { + pic_packet_t* packet = &packets[packet_idx]; + stbi_uc* dest = result + y * width * 4; + + switch (packet->type) + { + default: + return epuc("bad format", "packet has bad compression type"); + + case 0: + { // uncompressed + int x; + + for (x = 0; x < width; ++x, dest += 4) + if (!pic_readval(s, packet->channel, dest)) + return 0; + break; + } + + case 1: // Pure RLE + { + int left = width, i; + + while (left > 0) + { + stbi_uc count, value[4]; + + count = get8u(s); + if (at_eof(s)) + return epuc("bad file", "file too short (pure read count)"); + + if (count > left) + count = (uint8)left; + + if (!pic_readval(s, packet->channel, value)) + return 0; + + for (i = 0; i < count; ++i, dest += 4) + pic_copyval(packet->channel, dest, value); + left -= count; + } + } + break; + + case 2: + { // Mixed RLE + int left = width; + while (left > 0) + { + int count = get8(s), i; + if (at_eof(s)) + return epuc("bad file", "file too short (mixed read count)"); + + if (count >= 128) + { // Repeated + stbi_uc value[4]; + int i; + + if (count == 128) + count = get16(s); + else + count -= 127; + if (count > left) + return epuc("bad file", "scanline overrun"); + + if (!pic_readval(s, packet->channel, value)) + return 0; + + for (i = 0; i < count; ++i, dest += 4) + pic_copyval(packet->channel, dest, value); + } + else + { // Raw + ++count; + if (count > left) + return epuc("bad file", "scanline overrun"); + + for (i = 0; i < count; ++i, dest += 4) + if (!pic_readval(s, packet->channel, dest)) + return 0; + } + left -= count; + } + break; + } + } + } + } + + return result; +} + +static stbi_uc* pic_load(stbi* s, int* px, int* py, int* comp, int req_comp) +{ + stbi_uc* result; + int i, x, y; + + for (i = 0; i < 92; ++i) + get8(s); + + x = get16(s); + y = get16(s); + if (at_eof(s)) + return epuc("bad file", "file too short (pic header)"); + if ((1 << 28) / x < y) + return epuc("too large", "Image too large to decode"); + + get32(s); // skip `ratio' + get16(s); // skip `fields' + get16(s); // skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc*)malloc(x * y * 4); + memset(result, 0xff, x * y * 4); + + if (!pic_load2(s, x, y, comp, result)) + { + free(result); + result = 0; + } + *px = x; + *py = y; + if (req_comp == 0) + req_comp = *comp; + result = convert_format(result, 4, req_comp, x, y); + + return result; +} + +static int stbi_pic_test(stbi* s) +{ + int r = pic_test(s); + stbi_rewind(s); + return r; +} + +static stbi_uc* stbi_pic_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + return pic_load(s, x, y, comp, req_comp); +} + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb +typedef struct stbi_gif_lzw_struct +{ + int16 prefix; + uint8 first; + uint8 suffix; +} stbi_gif_lzw; + +typedef struct stbi_gif_struct +{ + int w, h; + stbi_uc* out; // output buffer (always 4 components) + int flags, bgindex, ratio, transparent, eflags; + uint8 pal[256][4]; + uint8 lpal[256][4]; + stbi_gif_lzw codes[4096]; + uint8* color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; +} stbi_gif; + +static int gif_test(stbi* s) +{ + int sz; + if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') + return 0; + sz = get8(s); + if (sz != '9' && sz != '7') + return 0; + if (get8(s) != 'a') + return 0; + return 1; +} + +static int stbi_gif_test(stbi* s) +{ + int r = gif_test(s); + stbi_rewind(s); + return r; +} + +static void stbi_gif_parse_colortable(stbi* s, uint8 pal[256][4], int num_entries, int transp) +{ + int i; + for (i = 0; i < num_entries; ++i) + { + pal[i][2] = get8u(s); + pal[i][1] = get8u(s); + pal[i][0] = get8u(s); + pal[i][3] = transp ? 0 : 255; + } +} + +static int stbi_gif_header(stbi* s, stbi_gif* g, int* comp, int is_info) +{ + uint8 version; + if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') + return e("not GIF", "Corrupt GIF"); + + version = get8u(s); + if (version != '7' && version != '9') + return e("not GIF", "Corrupt GIF"); + if (get8(s) != 'a') + return e("not GIF", "Corrupt GIF"); + + failure_reason = ""; + g->w = get16le(s); + g->h = get16le(s); + g->flags = get8(s); + g->bgindex = get8(s); + g->ratio = get8(s); + g->transparent = -1; + + if (comp != 0) + *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) + return 1; + + if (g->flags & 0x80) + stbi_gif_parse_colortable(s, g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi_gif_info_raw(stbi* s, int* x, int* y, int* comp) +{ + stbi_gif g; + if (!stbi_gif_header(s, &g, comp, 1)) + { + stbi_rewind(s); + return 0; + } + if (x) + *x = g.w; + if (y) + *y = g.h; + return 1; +} + +static void stbi_out_gif_code(stbi_gif* g, uint16 code) +{ + uint8 *p, *c; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi_out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) + return; + + p = &g->out[g->cur_x + g->cur_y]; + c = &g->color_table[g->codes[code].suffix * 4]; + + if (c[3] >= 128) + { + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) + { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) + { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static uint8* stbi_process_gif_raster(stbi* s, stbi_gif* g) +{ + uint8 lzw_cs; + int32 len, code; + uint32 first; + int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi_gif_lzw* p; + + lzw_cs = get8u(s); + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (code = 0; code < clear; code++) + { + g->codes[code].prefix = -1; + g->codes[code].first = (uint8)code; + g->codes[code].suffix = (uint8)code; + } + + // support no starting release code + avail = clear + 2; + oldcode = -1; + + len = 0; + for (;;) + { + if (valid_bits < codesize) + { + if (len == 0) + { + len = get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (int32)get8(s) << valid_bits; + valid_bits += 8; + } + else + { + int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-release path? + if (code == clear) + { // release code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } + else if (code == clear + 1) + { // end of stream code + skip(s, len); + while ((len = get8(s)) > 0) + skip(s, len); + return g->out; + } + else if (code <= avail) + { + if (first) + return epuc("no release code", "Corrupt GIF"); + + if (oldcode >= 0) + { + p = &g->codes[avail++]; + if (avail > 4096) + return epuc("too many codes", "Corrupt GIF"); + p->prefix = (int16)oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } + else if (code == avail) + return epuc("illegal code in raster", "Corrupt GIF"); + + stbi_out_gif_code(g, (uint16)code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) + { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } + else + { + return epuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +static void stbi_fill_gif_background(stbi_gif* g) +{ + int i; + uint8* c = g->pal[g->bgindex]; + // @OPTIMIZE: write a dword at a time + for (i = 0; i < g->w * g->h * 4; i += 4) + { + uint8* p = &g->out[i]; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +static uint8* stbi_gif_load_next(stbi* s, stbi_gif* g, int* comp, int req_comp) +{ + int i; + uint8* old_out = 0; + + if (g->out == 0) + { + if (!stbi_gif_header(s, g, comp, 0)) + return 0; // failure_reason set by stbi_gif_header + g->out = (uint8*)malloc(4 * g->w * g->h); + if (g->out == 0) + return epuc("outofmem", "Out of memory"); + stbi_fill_gif_background(g); + } + else + { + // animated-gif-only path + if (((g->eflags & 0x1C) >> 2) == 3) + { + old_out = g->out; + g->out = (uint8*)malloc(4 * g->w * g->h); + if (g->out == 0) + return epuc("outofmem", "Out of memory"); + memcpy(g->out, old_out, g->w * g->h * 4); + } + } + + for (;;) + { + switch (get8(s)) + { + case 0x2C: /* Image Descriptor */ + { + int32 x, y, w, h; + uint8* o; + + x = get16le(s); + y = get16le(s); + w = get16le(s); + h = get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return epuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + g->lflags = get8(s); + + if (g->lflags & 0x40) + { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } + else + { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) + { + stbi_gif_parse_colortable(s, g->lpal, 2 << (g->lflags & 7), + g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (uint8*)g->lpal; + } + else if (g->flags & 0x80) + { + for (i = 0; i < 256; ++i) // @OPTIMIZE: reset only the previous transparent + g->pal[i][3] = 255; + if (g->transparent >= 0 && (g->eflags & 0x01)) + g->pal[g->transparent][3] = 0; + g->color_table = (uint8*)g->pal; + } + else + return epuc("missing mColor table", "Corrupt GIF"); + + o = stbi_process_gif_raster(s, g); + if (o == NULL) + return NULL; + + if (req_comp && req_comp != 4) + o = convert_format(o, 4, req_comp, g->w, g->h); + return o; + } + + case 0x21: // Comment Extension. + { + int len; + if (get8(s) == 0xF9) + { // Graphic Control Extension. + len = get8(s); + if (len == 4) + { + g->eflags = get8(s); + get16le(s); // delay + g->transparent = get8(s); + } + else + { + skip(s, len); + break; + } + } + while ((len = get8(s)) != 0) + skip(s, len); + break; + } + + case 0x3B: // gif stream termination code + return (uint8*)1; + + default: + return epuc("unknown code", "Corrupt GIF"); + } + } +} + +static stbi_uc* stbi_gif_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + uint8* u = 0; + stbi_gif g = {0}; + + u = stbi_gif_load_next(s, &g, comp, req_comp); + if (u == (void*)1) + u = 0; // end of animated gif marker + if (u) + { + *x = g.w; + *y = g.h; + } + + return u; +} + +static int stbi_gif_info(stbi* s, int* x, int* y, int* comp) +{ + return stbi_gif_info_raw(s, x, y, comp); +} + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int hdr_test(stbi* s) +{ + const char* signature = "#?RADIANCE\n"; + int i; + for (i = 0; signature[i]; ++i) + if (get8(s) != signature[i]) + return 0; + return 1; +} + +static int stbi_hdr_test(stbi* s) +{ + int r = hdr_test(s); + stbi_rewind(s); + return r; +} + +#define HDR_BUFLEN 1024 +static char* hdr_gettoken(stbi* z, char* buffer) +{ + int len = 0; + char c = '\0'; + + c = (char)get8(z); + + while (!at_eof(z) && c != '\n') + { + buffer[len++] = c; + if (len == HDR_BUFLEN - 1) + { + // flush to end of line + while (!at_eof(z) && get8(z) != '\n') + ; + break; + } + c = (char)get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void hdr_convert(float* output, stbi_uc* input, int req_comp) +{ + if (input[3] != 0) + { + float f1; + // Exponent + f1 = (float)ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else + { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) + output[1] = 1; + if (req_comp == 4) + output[3] = 1; + } + else + { + switch (req_comp) + { + case 4: + output[3] = 1; /* fallthrough */ + case 3: + output[0] = output[1] = output[2] = 0; + break; + case 2: + output[1] = 1; /* fallthrough */ + case 1: + output[0] = 0; + break; + } + } +} + +static float* hdr_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + char buffer[HDR_BUFLEN]; + char* token; + int valid = 0; + int width, height; + stbi_uc* scanline; + float* hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1, c2, z; + + // Check identifier + if (strcmp(hdr_gettoken(s, buffer), "#?RADIANCE") != 0) + return epf("not HDR", "Corrupt HDR image"); + + // Parse header + for (;;) + { + token = hdr_gettoken(s, buffer); + if (token[0] == 0) + break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) + valid = 1; + } + + if (!valid) + return epf("unsupported format", "Unsupported HDR format"); + + // Parse mWidth and mHeight + // can't use sscanf() if we're not using stdio! + token = hdr_gettoken(s, buffer); + if (strncmp(token, "-Y ", 3)) + return epf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = strtol(token, &token, 10); + while (*token == ' ') + ++token; + if (strncmp(token, "+X ", 3)) + return epf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = strtol(token, NULL, 10); + + *x = width; + *y = height; + + *comp = 3; + if (req_comp == 0) + req_comp = 3; + + // Read data + hdr_data = (float*)malloc(height * width * req_comp * sizeof(float)); + + // Load image data + // image data is stored as some number of sca + if (width < 8 || width >= 32768) + { + // Read flat data + for (j = 0; j < height; ++j) + { + for (i = 0; i < width; ++i) + { + stbi_uc rgbe[4]; + main_decode_loop: + getn(s, rgbe, 4); + hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } + else + { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) + { + c1 = get8(s); + c2 = get8(s); + len = get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) + { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + uint8 rgbe[4]; + rgbe[0] = (uint8)c1; + rgbe[1] = (uint8)c2; + rgbe[2] = (uint8)len; + rgbe[3] = (uint8)get8u(s); + hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + free(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= get8(s); + if (len != width) + { + free(hdr_data); + free(scanline); + return epf("invalid decoded scanline length", "corrupt HDR"); + } + if (scanline == NULL) + scanline = (stbi_uc*)malloc(width * 4); + + for (k = 0; k < 4; ++k) + { + i = 0; + while (i < width) + { + count = get8u(s); + if (count > 128) + { + // Run + value = get8u(s); + count -= 128; + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } + else + { + // Dump + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = get8u(s); + } + } + } + for (i = 0; i < width; ++i) + hdr_convert(hdr_data + (j * width + i) * req_comp, scanline + i * 4, req_comp); + } + free(scanline); + } + + return hdr_data; +} + +static float* stbi_hdr_load(stbi* s, int* x, int* y, int* comp, int req_comp) +{ + return hdr_load(s, x, y, comp, req_comp); +} + +static int stbi_hdr_info(stbi* s, int* x, int* y, int* comp) +{ + char buffer[HDR_BUFLEN]; + char* token; + int valid = 0; + + if (strcmp(hdr_gettoken(s, buffer), "#?RADIANCE") != 0) + { + stbi_rewind(s); + return 0; + } + + for (;;) + { + token = hdr_gettoken(s, buffer); + if (token[0] == 0) + break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) + valid = 1; + } + + if (!valid) + { + stbi_rewind(s); + return 0; + } + token = hdr_gettoken(s, buffer); + if (strncmp(token, "-Y ", 3)) + { + stbi_rewind(s); + return 0; + } + token += 3; + *y = strtol(token, &token, 10); + while (*token == ' ') + ++token; + if (strncmp(token, "+X ", 3)) + { + stbi_rewind(s); + return 0; + } + token += 3; + *x = strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +static int stbi_bmp_info(stbi* s, int* x, int* y, int* comp) +{ + int hsz; + if (get8(s) != 'B' || get8(s) != 'M') + { + stbi_rewind(s); + return 0; + } + skip(s, 12); + hsz = get32le(s); + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) + { + stbi_rewind(s); + return 0; + } + if (hsz == 12) + { + *x = get16le(s); + *y = get16le(s); + } + else + { + *x = get32le(s); + *y = get32le(s); + } + if (get16le(s) != 1) + { + stbi_rewind(s); + return 0; + } + *comp = get16le(s) / 8; + return 1; +} + +static int stbi_psd_info(stbi* s, int* x, int* y, int* comp) +{ + int channelCount; + if (get32(s) != 0x38425053) + { + stbi_rewind(s); + return 0; + } + if (get16(s) != 1) + { + stbi_rewind(s); + return 0; + } + skip(s, 6); + channelCount = get16(s); + if (channelCount < 0 || channelCount > 16) + { + stbi_rewind(s); + return 0; + } + *y = get32(s); + *x = get32(s); + if (get16(s) != 8) + { + stbi_rewind(s); + return 0; + } + if (get16(s) != 3) + { + stbi_rewind(s); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi_pic_info(stbi* s, int* x, int* y, int* comp) +{ + int act_comp = 0, num_packets = 0, chained; + pic_packet_t packets[10]; + + skip(s, 92); + + *x = get16(s); + *y = get16(s); + if (at_eof(s)) + return 0; + if ((*x) != 0 && (1 << 28) / (*x) < (*y)) + { + stbi_rewind(s); + return 0; + } + + skip(s, 8); + + do + { + pic_packet_t* packet; + + if (num_packets == sizeof(packets) / sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = get8(s); + packet->size = get8u(s); + packet->type = get8u(s); + packet->channel = get8u(s); + act_comp |= packet->channel; + + if (at_eof(s)) + { + stbi_rewind(s); + return 0; + } + if (packet->size != 8) + { + stbi_rewind(s); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} + +static int stbi_info_main(stbi* s, int* x, int* y, int* comp) +{ + if (stbi_jpeg_info(s, x, y, comp)) + return 1; + if (stbi_png_info(s, x, y, comp)) + return 1; + if (stbi_gif_info(s, x, y, comp)) + return 1; + if (stbi_bmp_info(s, x, y, comp)) + return 1; + if (stbi_psd_info(s, x, y, comp)) + return 1; + if (stbi_pic_info(s, x, y, comp)) + return 1; +#ifndef STBI_NO_HDR + if (stbi_hdr_info(s, x, y, comp)) + return 1; +#endif + // test tga last because it's a crappy test! + if (stbi_tga_info(s, x, y, comp)) + return 1; + return e("unknown image type", "Image not of any known type, or corrupt"); +} + +#ifndef STBI_NO_STDIO +int stbi_info(char const* filename, int* x, int* y, int* comp) +{ + FILE* f = fopen(filename, "rb"); + int result; + if (!f) + return e("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +int stbi_info_from_file(FILE* f, int* x, int* y, int* comp) +{ + int r; + stbi s; + long pos = ftell(f); + start_file(&s, f); + r = stbi_info_main(&s, x, y, comp); + fseek(f, pos, SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +int stbi_info_from_memory(stbi_uc const* buffer, int len, int* x, int* y, int* comp) +{ + stbi s; + start_mem(&s, buffer, len); + return stbi_info_main(&s, x, y, comp); +} + +int stbi_info_from_callbacks(stbi_io_callbacks const* c, void* user, int* x, int* y, int* comp) +{ + stbi s; + start_callbacks(&s, (stbi_io_callbacks*)c, user); + return stbi_info_main(&s, x, y, comp); +} + +#endif // STBI_HEADER_FILE_ONLY + +/* + revision history: + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly + improvements 1.32 (2011-07-13) support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to loadSound files via callbacks to accomidate custom input streams (Ben + Wenger) removed deprecated format-specific test/load functions removed support for installable + file formats (stbi_loader) -- would have been broken for IO callbacks anyway error cases in bmp + and tga give messages and don't leak (Raymond Barbiero, grisha) fix inefficiency in decoding + 32-bit BMP (David Woo) 1.29 (2010-08-16) various warning fixes from Aurelien Pocheville 1.28 + (2010-08-01) fix bug in GIF palette transparency (SpartanJ) 1.27 (2010-08-01) cast-to-uint8 to + fix warnings 1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ 1.25 + (2010-07-17) refix trans_data warning (Won Chun) 1.24 (2010-07-12) perf improvements reading from + files on platforms with lock-heavy fgetc() minor perf improvements for jpeg deprecated + type-specific functions so we'll get feedback if they're needed attempt to fix trans_data warning + (Won Chun) 1.23 fixed bug in iPhone support 1.22 (2010-07-10) removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.e. Janez (U+017D)emva) + 1.21 fix use of 'uint8' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 2008-08-02 + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 first released version +*/ diff --git a/src/3rdparty/stb_collection/stb_image_write.h b/src/3rdparty/stb_collection/stb_image_write.h new file mode 100644 index 0000000..e4b32ed --- /dev/null +++ b/src/3rdparty/stb_collection/stb_image_write.h @@ -0,0 +1,1724 @@ +/* stb_image_write - v1.16 - public domain - http://nothings.org/stb + writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015 + no warranty implied; use at your own risk + + Before #including, + + #define STB_IMAGE_WRITE_IMPLEMENTATION + + in the file that you want to have the implementation. + + Will probably not work correctly with strict-aliasing optimizations. + +ABOUT: + + This header file is a library for writing images to C stdio or a callback. + + The PNG output is not optimal; it is 20-50% larger than the file + written by a decent optimizing implementation; though providing a custom + zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that. + This library is designed for source code compactness and simplicity, + not optimal image file size or run-time performance. + +BUILDING: + + You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h. + You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace + malloc,realloc,free. + You can #define STBIW_MEMMOVE() to replace memmove() + You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function + for PNG compression (instead of the builtin one), it must have the following signature: + unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality); + The returned data will be freed with STBIW_FREE() (free() by default), + so it must be heap allocated with STBIW_MALLOC() (malloc() by default), + +UNICODE: + + If compiling for Windows and you wish to use Unicode filenames, compile + with + #define STBIW_WINDOWS_UTF8 + and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert + Windows wchar_t filenames to utf8. + +USAGE: + + There are five functions, one for each image file format: + + int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); + int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); + int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); + + void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically + + There are also five equivalent functions that use an arbitrary write function. You are + expected to open/close your file-equivalent before and after calling these: + + int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); + int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); + int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); + int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + + where the callback is: + void stbi_write_func(void *context, void *data, int size); + + You can configure it with these global variables: + int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE + int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression + int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode + + + You can define STBI_WRITE_NO_STDIO to disable the file variant of these + functions, so the library will not use stdio.h at all. However, this will + also disable HDR writing, because it requires stdio for formatted output. + + Each function returns 0 on failure and non-0 on success. + + The functions create an image file defined by the parameters. The image + is a rectangle of pixels stored from left-to-right, top-to-bottom. + Each pixel contains 'comp' channels of data stored interleaved with 8-bits + per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is + monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall. + The *data pointer points to the first byte of the top-left-most pixel. + For PNG, "stride_in_bytes" is the distance in bytes from the first byte of + a row of pixels to the first byte of the next row of pixels. + + PNG creates output files with the same number of components as the input. + The BMP format expands Y to RGB in the file format and does not + output alpha. + + PNG supports writing rectangles of data even when the bytes storing rows of + data are not consecutive in memory (e.g. sub-rectangles of a larger image), + by supplying the stride between the beginning of adjacent rows. The other + formats do not. (Thus you cannot write a native-format BMP through the BMP + writer, both because it is in BGR order and because it may have padding + at the end of the line.) + + PNG allows you to set the deflate compression level by setting the global + variable 'stbi_write_png_compression_level' (it defaults to 8). + + HDR expects linear float data. Since the format is always 32-bit rgb(e) + data, alpha (if provided) is discarded, and for monochrome data it is + replicated across all three channels. + + TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed + data, set the global variable 'stbi_write_tga_with_rle' to 0. + + JPEG does ignore alpha channels in input data; quality is between 1 and 100. + Higher quality looks better but results in a bigger image. + JPEG baseline (no JPEG progressive). + +CREDITS: + + + Sean Barrett - PNG/BMP/TGA + Baldur Karlsson - HDR + Jean-Sebastien Guay - TGA monochrome + Tim Kelsey - misc enhancements + Alan Hickman - TGA RLE + Emmanuel Julien - initial file IO callback implementation + Jon Olick - original jo_jpeg.cpp code + Daniel Gibson - integrate JPEG, allow external zlib + Aarni Koskela - allow choosing PNG filter + + bugfixes: + github:Chribba + Guillaume Chereau + github:jry2 + github:romigrou + Sergio Gonzalez + Jonas Karlsson + Filip Wasil + Thatcher Ulrich + github:poppolopoppo + Patrick Boettcher + github:xeekworx + Cap Petschulat + Simon Rodriguez + Ivan Tikhonov + github:ignotion + Adam Schackart + Andrew Kensler + +LICENSE + + See end of file for license information. + +*/ + +#ifndef INCLUDE_STB_IMAGE_WRITE_H +#define INCLUDE_STB_IMAGE_WRITE_H + +#include + +// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline' +#ifndef STBIWDEF +#ifdef STB_IMAGE_WRITE_STATIC +#define STBIWDEF static +#else +#ifdef __cplusplus +#define STBIWDEF extern "C" +#else +#define STBIWDEF extern +#endif +#endif +#endif + +#ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations +STBIWDEF int stbi_write_tga_with_rle; +STBIWDEF int stbi_write_png_compression_level; +STBIWDEF int stbi_write_force_png_filter; +#endif + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality); + +#ifdef STBIW_WINDOWS_UTF8 +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif +#endif + +typedef void stbi_write_func(void *context, void *data, int size); + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); + +STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean); + +#endif//INCLUDE_STB_IMAGE_WRITE_H + +#ifdef STB_IMAGE_WRITE_IMPLEMENTATION + +#ifdef _WIN32 + #ifndef _CRT_SECURE_NO_WARNINGS + #define _CRT_SECURE_NO_WARNINGS + #endif + #ifndef _CRT_NONSTDC_NO_DEPRECATE + #define _CRT_NONSTDC_NO_DEPRECATE + #endif +#endif + +#ifndef STBI_WRITE_NO_STDIO +#include +#endif // STBI_WRITE_NO_STDIO + +#include +#include +#include +#include + +#if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED)) +// ok +#elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)." +#endif + +#ifndef STBIW_MALLOC +#define STBIW_MALLOC(sz) malloc(sz) +#define STBIW_REALLOC(p,newsz) realloc(p,newsz) +#define STBIW_FREE(p) free(p) +#endif + +#ifndef STBIW_REALLOC_SIZED +#define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz) +#endif + + +#ifndef STBIW_MEMMOVE +#define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz) +#endif + + +#ifndef STBIW_ASSERT +#include +#define STBIW_ASSERT(x) assert(x) +#endif + +#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) + +#ifdef STB_IMAGE_WRITE_STATIC +static int stbi_write_png_compression_level = 8; +static int stbi_write_tga_with_rle = 1; +static int stbi_write_force_png_filter = -1; +#else +int stbi_write_png_compression_level = 8; +int stbi_write_tga_with_rle = 1; +int stbi_write_force_png_filter = -1; +#endif + +static int stbi__flip_vertically_on_write = 0; + +STBIWDEF void stbi_flip_vertically_on_write(int flag) +{ + stbi__flip_vertically_on_write = flag; +} + +typedef struct +{ + stbi_write_func *func; + void *context; + unsigned char buffer[64]; + int buf_used; +} stbi__write_context; + +// initialize a callback-based context +static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) +{ + s->func = c; + s->context = context; +} + +#ifndef STBI_WRITE_NO_STDIO + +static void stbi__stdio_write(void *context, void *data, int size) +{ + fwrite(data,1,size,(FILE*) context); +} + +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) +#ifdef __cplusplus +#define STBIW_EXTERN extern "C" +#else +#define STBIW_EXTERN extern +#endif +STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + +STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbiw__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + +static int stbi__start_write_file(stbi__write_context *s, const char *filename) +{ + FILE *f = stbiw__fopen(filename, "wb"); + stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f); + return f != NULL; +} + +static void stbi__end_write_file(stbi__write_context *s) +{ + fclose((FILE *)s->context); +} + +#endif // !STBI_WRITE_NO_STDIO + +typedef unsigned int stbiw_uint32; +typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]; + +static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) +{ + while (*fmt) { + switch (*fmt++) { + case ' ': break; + case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int)); + s->func(s->context,&x,1); + break; } + case '2': { int x = va_arg(v,int); + unsigned char b[2]; + b[0] = STBIW_UCHAR(x); + b[1] = STBIW_UCHAR(x>>8); + s->func(s->context,b,2); + break; } + case '4': { stbiw_uint32 x = va_arg(v,int); + unsigned char b[4]; + b[0]=STBIW_UCHAR(x); + b[1]=STBIW_UCHAR(x>>8); + b[2]=STBIW_UCHAR(x>>16); + b[3]=STBIW_UCHAR(x>>24); + s->func(s->context,b,4); + break; } + default: + STBIW_ASSERT(0); + return; + } + } +} + +static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) +{ + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); +} + +static void stbiw__write_flush(stbi__write_context *s) +{ + if (s->buf_used) { + s->func(s->context, &s->buffer, s->buf_used); + s->buf_used = 0; + } +} + +static void stbiw__putc(stbi__write_context *s, unsigned char c) +{ + s->func(s->context, &c, 1); +} + +static void stbiw__write1(stbi__write_context *s, unsigned char a) +{ + if ((size_t)s->buf_used + 1 > sizeof(s->buffer)) + stbiw__write_flush(s); + s->buffer[s->buf_used++] = a; +} + +static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) +{ + int n; + if ((size_t)s->buf_used + 3 > sizeof(s->buffer)) + stbiw__write_flush(s); + n = s->buf_used; + s->buf_used = n+3; + s->buffer[n+0] = a; + s->buffer[n+1] = b; + s->buffer[n+2] = c; +} + +static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d) +{ + unsigned char bg[3] = { 255, 0, 255}, px[3]; + int k; + + if (write_alpha < 0) + stbiw__write1(s, d[comp - 1]); + + switch (comp) { + case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case + case 1: + if (expand_mono) + stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp + else + stbiw__write1(s, d[0]); // monochrome TGA + break; + case 4: + if (!write_alpha) { + // composite against pink background + for (k = 0; k < 3; ++k) + px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255; + stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]); + break; + } + /* FALLTHROUGH */ + case 3: + stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]); + break; + } + if (write_alpha > 0) + stbiw__write1(s, d[comp - 1]); +} + +static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono) +{ + stbiw_uint32 zero = 0; + int i,j, j_end; + + if (y <= 0) + return; + + if (stbi__flip_vertically_on_write) + vdir *= -1; + + if (vdir < 0) { + j_end = -1; j = y-1; + } else { + j_end = y; j = 0; + } + + for (; j != j_end; j += vdir) { + for (i=0; i < x; ++i) { + unsigned char *d = (unsigned char *) data + (j*x+i)*comp; + stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d); + } + stbiw__write_flush(s); + s->func(s->context, &zero, scanline_pad); + } +} + +static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...) +{ + if (y < 0 || x < 0) { + return 0; + } else { + va_list v; + va_start(v, fmt); + stbiw__writefv(s, fmt, v); + va_end(v); + stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono); + return 1; + } +} + +static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) +{ + if (comp != 4) { + // write RGB bitmap + int pad = (-x*3) & 3; + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad, + "11 4 22 4" "4 44 22 444444", + 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header + 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header + } else { + // RGBA bitmaps need a v4 header + // use BI_BITFIELDS mode with 32bpp and alpha mask + // (straight BI_RGB with alpha mask doesn't work in most readers) + return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0, + "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444", + 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header + 108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header + } +} + +STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_bmp_core(&s, x, y, comp, data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_bmp_core(&s, x, y, comp, data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif //!STBI_WRITE_NO_STDIO + +static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) +{ + int has_alpha = (comp == 2 || comp == 4); + int colorbytes = has_alpha ? comp-1 : comp; + int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 + + if (y < 0 || x < 0) + return 0; + + if (!stbi_write_tga_with_rle) { + return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0, + "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); + } else { + int i,j,k; + int jend, jdir; + + stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8); + + if (stbi__flip_vertically_on_write) { + j = 0; + jend = y; + jdir = 1; + } else { + j = y-1; + jend = -1; + jdir = -1; + } + for (; j != jend; j += jdir) { + unsigned char *row = (unsigned char *) data + j * x * comp; + int len; + + for (i = 0; i < x; i += len) { + unsigned char *begin = row + i * comp; + int diff = 1; + len = 1; + + if (i < x - 1) { + ++len; + diff = memcmp(begin, row + (i + 1) * comp, comp); + if (diff) { + const unsigned char *prev = begin; + for (k = i + 2; k < x && len < 128; ++k) { + if (memcmp(prev, row + k * comp, comp)) { + prev += comp; + ++len; + } else { + --len; + break; + } + } + } else { + for (k = i + 2; k < x && len < 128; ++k) { + if (!memcmp(begin, row + k * comp, comp)) { + ++len; + } else { + break; + } + } + } + } + + if (diff) { + unsigned char header = STBIW_UCHAR(len - 1); + stbiw__write1(s, header); + for (k = 0; k < len; ++k) { + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp); + } + } else { + unsigned char header = STBIW_UCHAR(len - 129); + stbiw__write1(s, header); + stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); + } + } + } + stbiw__write_flush(s); + } + return 1; +} + +STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_tga_core(&s, x, y, comp, (void *) data); +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_tga_core(&s, x, y, comp, (void *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR writer +// by Baldur Karlsson + +#define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) + +#ifndef STBI_WRITE_NO_STDIO + +static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) +{ + int exponent; + float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2])); + + if (maxcomp < 1e-32f) { + rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0; + } else { + float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp; + + rgbe[0] = (unsigned char)(linear[0] * normalize); + rgbe[1] = (unsigned char)(linear[1] * normalize); + rgbe[2] = (unsigned char)(linear[2] * normalize); + rgbe[3] = (unsigned char)(exponent + 128); + } +} + +static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) +{ + unsigned char lengthbyte = STBIW_UCHAR(length+128); + STBIW_ASSERT(length+128 <= 255); + s->func(s->context, &lengthbyte, 1); + s->func(s->context, &databyte, 1); +} + +static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) +{ + unsigned char lengthbyte = STBIW_UCHAR(length); + STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code + s->func(s->context, &lengthbyte, 1); + s->func(s->context, data, length); +} + +static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline) +{ + unsigned char scanlineheader[4] = { 2, 2, 0, 0 }; + unsigned char rgbe[4]; + float linear[3]; + int x; + + scanlineheader[2] = (width&0xff00)>>8; + scanlineheader[3] = (width&0x00ff); + + /* skip RLE for images too small or large */ + if (width < 8 || width >= 32768) { + for (x=0; x < width; x++) { + switch (ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + s->func(s->context, rgbe, 4); + } + } else { + int c,r; + /* encode into scratch buffer */ + for (x=0; x < width; x++) { + switch(ncomp) { + case 4: /* fallthrough */ + case 3: linear[2] = scanline[x*ncomp + 2]; + linear[1] = scanline[x*ncomp + 1]; + linear[0] = scanline[x*ncomp + 0]; + break; + default: + linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; + break; + } + stbiw__linear_to_rgbe(rgbe, linear); + scratch[x + width*0] = rgbe[0]; + scratch[x + width*1] = rgbe[1]; + scratch[x + width*2] = rgbe[2]; + scratch[x + width*3] = rgbe[3]; + } + + s->func(s->context, scanlineheader, 4); + + /* RLE each component separately */ + for (c=0; c < 4; c++) { + unsigned char *comp = &scratch[width*c]; + + x = 0; + while (x < width) { + // find first run + r = x; + while (r+2 < width) { + if (comp[r] == comp[r+1] && comp[r] == comp[r+2]) + break; + ++r; + } + if (r+2 >= width) + r = width; + // dump up to first run + while (x < r) { + int len = r-x; + if (len > 128) len = 128; + stbiw__write_dump_data(s, len, &comp[x]); + x += len; + } + // if there's a run, output it + if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd + // find next byte after run + while (r < width && comp[r] == comp[x]) + ++r; + // output run up to r + while (x < r) { + int len = r-x; + if (len > 127) len = 127; + stbiw__write_run_data(s, len, comp[x]); + x += len; + } + } + } + } + } +} + +static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) +{ + if (y <= 0 || x <= 0 || data == NULL) + return 0; + else { + // Each component is stored separately. Allocate scratch space for full output scanline. + unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4); + int i, len; + char buffer[128]; + char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; + s->func(s->context, header, sizeof(header)-1); + +#ifdef __STDC_LIB_EXT1__ + len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#else + len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); +#endif + s->func(s->context, buffer, len); + + for(i=0; i < y; i++) + stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)); + STBIW_FREE(scratch); + return 1; + } +} + +STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_hdr_core(&s, x, y, comp, (float *) data); +} + +STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif // STBI_WRITE_NO_STDIO + + +////////////////////////////////////////////////////////////////////////////// +// +// PNG writer +// + +#ifndef STBIW_ZLIB_COMPRESS +// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() +#define stbiw__sbraw(a) ((int *) (void *) (a) - 2) +#define stbiw__sbm(a) stbiw__sbraw(a)[0] +#define stbiw__sbn(a) stbiw__sbraw(a)[1] + +#define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a)) +#define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0) +#define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a))) + +#define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v)) +#define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0) +#define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0) + +static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) +{ + int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1; + void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2); + STBIW_ASSERT(p); + if (p) { + if (!*arr) ((int *) p)[1] = 0; + *arr = (void *) ((int *) p + 2); + stbiw__sbm(*arr) = m; + } + return *arr; +} + +static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) +{ + while (*bitcount >= 8) { + stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer)); + *bitbuffer >>= 8; + *bitcount -= 8; + } + return data; +} + +static int stbiw__zlib_bitrev(int code, int codebits) +{ + int res=0; + while (codebits--) { + res = (res << 1) | (code & 1); + code >>= 1; + } + return res; +} + +static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) +{ + int i; + for (i=0; i < limit && i < 258; ++i) + if (a[i] != b[i]) break; + return i; +} + +static unsigned int stbiw__zhash(unsigned char *data) +{ + stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16); + hash ^= hash << 3; + hash += hash >> 5; + hash ^= hash << 4; + hash += hash >> 17; + hash ^= hash << 25; + hash += hash >> 6; + return hash; +} + +#define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount)) +#define stbiw__zlib_add(code,codebits) \ + (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush()) +#define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c) +// default huffman tables +#define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8) +#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9) +#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7) +#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8) +#define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n)) +#define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n)) + +#define stbiw__ZHASH 16384 + +#endif // STBIW_ZLIB_COMPRESS + +STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) +{ +#ifdef STBIW_ZLIB_COMPRESS + // user provided a zlib compress implementation, use that + return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality); +#else // use builtin + static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 }; + static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; + static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 }; + static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 }; + unsigned int bitbuf=0; + int i,j, bitcount=0; + unsigned char *out = NULL; + unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**)); + if (hash_table == NULL) + return NULL; + if (quality < 5) quality = 5; + + stbiw__sbpush(out, 0x78); // DEFLATE 32K window + stbiw__sbpush(out, 0x5e); // FLEVEL = 1 + stbiw__zlib_add(1,1); // BFINAL = 1 + stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman + + for (i=0; i < stbiw__ZHASH; ++i) + hash_table[i] = NULL; + + i=0; + while (i < data_len-3) { + // hash next 3 bytes of data to be compressed + int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3; + unsigned char *bestloc = 0; + unsigned char **hlist = hash_table[h]; + int n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32768) { // if entry lies within window + int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i); + if (d >= best) { best=d; bestloc=hlist[j]; } + } + } + // when hash table entry is too long, delete half the entries + if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) { + STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality); + stbiw__sbn(hash_table[h]) = quality; + } + stbiw__sbpush(hash_table[h],data+i); + + if (bestloc) { + // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal + h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1); + hlist = hash_table[h]; + n = stbiw__sbcount(hlist); + for (j=0; j < n; ++j) { + if (hlist[j]-data > i-32767) { + int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1); + if (e > best) { // if next match is better, bail on current match + bestloc = NULL; + break; + } + } + } + } + + if (bestloc) { + int d = (int) (data+i - bestloc); // distance back + STBIW_ASSERT(d <= 32767 && best <= 258); + for (j=0; best > lengthc[j+1]-1; ++j); + stbiw__zlib_huff(j+257); + if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]); + for (j=0; d > distc[j+1]-1; ++j); + stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5); + if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]); + i += best; + } else { + stbiw__zlib_huffb(data[i]); + ++i; + } + } + // write out final bytes + for (;i < data_len; ++i) + stbiw__zlib_huffb(data[i]); + stbiw__zlib_huff(256); // end of block + // pad with 0 bits to byte boundary + while (bitcount) + stbiw__zlib_add(0,1); + + for (i=0; i < stbiw__ZHASH; ++i) + (void) stbiw__sbfree(hash_table[i]); + STBIW_FREE(hash_table); + + // store uncompressed instead if compression was worse + if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) { + stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1 + for (j = 0; j < data_len;) { + int blocklen = data_len - j; + if (blocklen > 32767) blocklen = 32767; + stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression + stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN + stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN + stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8)); + memcpy(out+stbiw__sbn(out), data+j, blocklen); + stbiw__sbn(out) += blocklen; + j += blocklen; + } + } + + { + // compute adler32 on input + unsigned int s1=1, s2=0; + int blocklen = (int) (data_len % 5552); + j=0; + while (j < data_len) { + for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; } + s1 %= 65521; s2 %= 65521; + j += blocklen; + blocklen = 5552; + } + stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s2)); + stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8)); + stbiw__sbpush(out, STBIW_UCHAR(s1)); + } + *out_len = stbiw__sbn(out); + // make returned pointer freeable + STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len); + return (unsigned char *) stbiw__sbraw(out); +#endif // STBIW_ZLIB_COMPRESS +} + +static unsigned int stbiw__crc32(unsigned char *buffer, int len) +{ +#ifdef STBIW_CRC32 + return STBIW_CRC32(buffer, len); +#else + static unsigned int crc_table[256] = + { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + unsigned int crc = ~0u; + int i; + for (i=0; i < len; ++i) + crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]; + return ~crc; +#endif +} + +#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4) +#define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v)); +#define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3]) + +static void stbiw__wpcrc(unsigned char **data, int len) +{ + unsigned int crc = stbiw__crc32(*data - len - 4, len+4); + stbiw__wp32(*data, crc); +} + +static unsigned char stbiw__paeth(int a, int b, int c) +{ + int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c); + if (pa <= pb && pa <= pc) return STBIW_UCHAR(a); + if (pb <= pc) return STBIW_UCHAR(b); + return STBIW_UCHAR(c); +} + +// @OPTIMIZE: provide an option that always forces left-predict or paeth predict +static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer) +{ + static int mapping[] = { 0,1,2,3,4 }; + static int firstmap[] = { 0,1,0,5,6 }; + int *mymap = (y != 0) ? mapping : firstmap; + int i; + int type = mymap[filter_type]; + unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y); + int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes; + + if (type==0) { + memcpy(line_buffer, z, width*n); + return; + } + + // first loop isn't optimized since it's just one pixel + for (i = 0; i < n; ++i) { + switch (type) { + case 1: line_buffer[i] = z[i]; break; + case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break; + case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break; + case 5: line_buffer[i] = z[i]; break; + case 6: line_buffer[i] = z[i]; break; + } + } + switch (type) { + case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break; + case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break; + case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break; + case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break; + case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break; + case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break; + } +} + +STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len) +{ + int force_filter = stbi_write_force_png_filter; + int ctype[5] = { -1, 0, 4, 2, 6 }; + unsigned char sig[8] = { 137,80,78,71,13,10,26,10 }; + unsigned char *out,*o, *filt, *zlib; + signed char *line_buffer; + int j,zlen; + + if (stride_bytes == 0) + stride_bytes = x * n; + + if (force_filter >= 5) { + force_filter = -1; + } + + filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0; + line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; } + for (j=0; j < y; ++j) { + int filter_type; + if (force_filter > -1) { + filter_type = force_filter; + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer); + } else { // Estimate the best filter by running through all of them: + int best_filter = 0, best_filter_val = 0x7fffffff, est, i; + for (filter_type = 0; filter_type < 5; filter_type++) { + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer); + + // Estimate the entropy of the line using this filter; the less, the better. + est = 0; + for (i = 0; i < x*n; ++i) { + est += abs((signed char) line_buffer[i]); + } + if (est < best_filter_val) { + best_filter_val = est; + best_filter = filter_type; + } + } + if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it + stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer); + filter_type = best_filter; + } + } + // when we get here, filter_type contains the filter type, and line_buffer contains the data + filt[j*(x*n+1)] = (unsigned char) filter_type; + STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n); + } + STBIW_FREE(line_buffer); + zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level); + STBIW_FREE(filt); + if (!zlib) return 0; + + // each tag requires 12 bytes of overhead + out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12); + if (!out) return 0; + *out_len = 8 + 12+13 + 12+zlen + 12; + + o=out; + STBIW_MEMMOVE(o,sig,8); o+= 8; + stbiw__wp32(o, 13); // header length + stbiw__wptag(o, "IHDR"); + stbiw__wp32(o, x); + stbiw__wp32(o, y); + *o++ = 8; + *o++ = STBIW_UCHAR(ctype[n]); + *o++ = 0; + *o++ = 0; + *o++ = 0; + stbiw__wpcrc(&o,13); + + stbiw__wp32(o, zlen); + stbiw__wptag(o, "IDAT"); + STBIW_MEMMOVE(o, zlib, zlen); + o += zlen; + STBIW_FREE(zlib); + stbiw__wpcrc(&o, zlen); + + stbiw__wp32(o,0); + stbiw__wptag(o, "IEND"); + stbiw__wpcrc(&o,0); + + STBIW_ASSERT(o == out + *out_len); + + return out; +} + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes) +{ + FILE *f; + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + + f = stbiw__fopen(filename, "wb"); + if (!f) { STBIW_FREE(png); return 0; } + fwrite(png, 1, len, f); + fclose(f); + STBIW_FREE(png); + return 1; +} +#endif + +STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes) +{ + int len; + unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); + if (png == NULL) return 0; + func(context, png, len); + STBIW_FREE(png); + return 1; +} + + +/* *************************************************************************** + * + * JPEG writer + * + * This is based on Jon Olick's jo_jpeg.cpp: + * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html + */ + +static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18, + 24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 }; + +static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) { + int bitBuf = *bitBufP, bitCnt = *bitCntP; + bitCnt += bs[1]; + bitBuf |= bs[0] << (24 - bitCnt); + while(bitCnt >= 8) { + unsigned char c = (bitBuf >> 16) & 255; + stbiw__putc(s, c); + if(c == 255) { + stbiw__putc(s, 0); + } + bitBuf <<= 8; + bitCnt -= 8; + } + *bitBufP = bitBuf; + *bitCntP = bitCnt; +} + +static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) { + float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p; + float z1, z2, z3, z4, z5, z11, z13; + + float tmp0 = d0 + d7; + float tmp7 = d0 - d7; + float tmp1 = d1 + d6; + float tmp6 = d1 - d6; + float tmp2 = d2 + d5; + float tmp5 = d2 - d5; + float tmp3 = d3 + d4; + float tmp4 = d3 - d4; + + // Even part + float tmp10 = tmp0 + tmp3; // phase 2 + float tmp13 = tmp0 - tmp3; + float tmp11 = tmp1 + tmp2; + float tmp12 = tmp1 - tmp2; + + d0 = tmp10 + tmp11; // phase 3 + d4 = tmp10 - tmp11; + + z1 = (tmp12 + tmp13) * 0.707106781f; // c4 + d2 = tmp13 + z1; // phase 5 + d6 = tmp13 - z1; + + // Odd part + tmp10 = tmp4 + tmp5; // phase 2 + tmp11 = tmp5 + tmp6; + tmp12 = tmp6 + tmp7; + + // The rotator is modified from fig 4-8 to avoid extra negations. + z5 = (tmp10 - tmp12) * 0.382683433f; // c6 + z2 = tmp10 * 0.541196100f + z5; // c2-c6 + z4 = tmp12 * 1.306562965f + z5; // c2+c6 + z3 = tmp11 * 0.707106781f; // c4 + + z11 = tmp7 + z3; // phase 5 + z13 = tmp7 - z3; + + *d5p = z13 + z2; // phase 6 + *d3p = z13 - z2; + *d1p = z11 + z4; + *d7p = z11 - z4; + + *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6; +} + +static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) { + int tmp1 = val < 0 ? -val : val; + val = val < 0 ? val-1 : val; + bits[1] = 1; + while(tmp1 >>= 1) { + ++bits[1]; + } + bits[0] = val & ((1<0)&&(DU[end0pos]==0); --end0pos) { + } + // end0pos = first element in reverse order !=0 + if(end0pos == 0) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + return DU[0]; + } + for(i = 1; i <= end0pos; ++i) { + int startpos = i; + int nrzeroes; + unsigned short bits[2]; + for (; DU[i]==0 && i<=end0pos; ++i) { + } + nrzeroes = i-startpos; + if ( nrzeroes >= 16 ) { + int lng = nrzeroes>>4; + int nrmarker; + for (nrmarker=1; nrmarker <= lng; ++nrmarker) + stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes); + nrzeroes &= 15; + } + stbiw__jpg_calcBits(DU[i], bits); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]); + stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits); + } + if(end0pos != 63) { + stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); + } + return DU[0]; +} + +static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) { + // Constants that don't pollute global namespace + static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0}; + static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d}; + static const unsigned char std_ac_luminance_values[] = { + 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, + 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, + 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, + 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, + 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, + 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, + 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0}; + static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; + static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77}; + static const unsigned char std_ac_chrominance_values[] = { + 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, + 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, + 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, + 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, + 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, + 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, + 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa + }; + // Huffman tables + static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}}; + static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}}; + static const unsigned short YAC_HT[256][2] = { + {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const unsigned short UVAC_HT[256][2] = { + {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, + {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0}, + {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} + }; + static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22, + 37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99}; + static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99, + 99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99}; + static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, + 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; + + int row, col, i, k, subsample; + float fdtbl_Y[64], fdtbl_UV[64]; + unsigned char YTable[64], UVTable[64]; + + if(!data || !width || !height || comp > 4 || comp < 1) { + return 0; + } + + quality = quality ? quality : 90; + subsample = quality <= 90 ? 1 : 0; + quality = quality < 1 ? 1 : quality > 100 ? 100 : quality; + quality = quality < 50 ? 5000 / quality : 200 - quality * 2; + + for(i = 0; i < 64; ++i) { + int uvti, yti = (YQT[i]*quality+50)/100; + YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti); + uvti = (UVQT[i]*quality+50)/100; + UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti); + } + + for(row = 0, k = 0; row < 8; ++row) { + for(col = 0; col < 8; ++col, ++k) { + fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); + } + } + + // Write Headers + { + static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 }; + static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 }; + const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width), + 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 }; + s->func(s->context, (void*)head0, sizeof(head0)); + s->func(s->context, (void*)YTable, sizeof(YTable)); + stbiw__putc(s, 1); + s->func(s->context, UVTable, sizeof(UVTable)); + s->func(s->context, (void*)head1, sizeof(head1)); + s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1); + s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values)); + stbiw__putc(s, 0x10); // HTYACinfo + s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1); + s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values)); + stbiw__putc(s, 1); // HTUDCinfo + s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values)); + stbiw__putc(s, 0x11); // HTUACinfo + s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1); + s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values)); + s->func(s->context, (void*)head2, sizeof(head2)); + } + + // Encode 8x8 macroblocks + { + static const unsigned short fillBits[] = {0x7F, 7}; + int DCY=0, DCU=0, DCV=0; + int bitBuf=0, bitCnt=0; + // comp == 2 is grey+alpha (alpha is ignored) + int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0; + const unsigned char *dataR = (const unsigned char *)data; + const unsigned char *dataG = dataR + ofsG; + const unsigned char *dataB = dataR + ofsB; + int x, y, pos; + if(subsample) { + for(y = 0; y < height; y += 16) { + for(x = 0; x < width; x += 16) { + float Y[256], U[256], V[256]; + for(row = y, pos = 0; row < y+16; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+16; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); + + // subsample U,V + { + float subU[64], subV[64]; + int yy, xx; + for(yy = 0, pos = 0; yy < 8; ++yy) { + for(xx = 0; xx < 8; ++xx, ++pos) { + int j = yy*32+xx*2; + subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f; + subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f; + } + } + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + } else { + for(y = 0; y < height; y += 8) { + for(x = 0; x < width; x += 8) { + float Y[64], U[64], V[64]; + for(row = y, pos = 0; row < y+8; ++row) { + // row >= height => use last input row + int clamped_row = (row < height) ? row : height - 1; + int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; + for(col = x; col < x+8; ++col, ++pos) { + // if col >= width => use pixel from last input column + int p = base_p + ((col < width) ? col : (width-1))*comp; + float r = dataR[p], g = dataG[p], b = dataB[p]; + Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; + U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; + V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; + } + } + + DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT); + DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); + DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); + } + } + } + + // Do the bit alignment of the EOI marker + stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); + } + + // EOI + stbiw__putc(s, 0xFF); + stbiw__putc(s, 0xD9); + + return 1; +} + +STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + stbi__start_write_callbacks(&s, func, context); + return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality); +} + + +#ifndef STBI_WRITE_NO_STDIO +STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) +{ + stbi__write_context s = { 0 }; + if (stbi__start_write_file(&s,filename)) { + int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); + stbi__end_write_file(&s); + return r; + } else + return 0; +} +#endif + +#endif // STB_IMAGE_WRITE_IMPLEMENTATION + +/* Revision history + 1.16 (2021-07-11) + make Deflate code emit uncompressed blocks when it would otherwise expand + support writing BMPs with alpha channel + 1.15 (2020-07-13) unknown + 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels + 1.13 + 1.12 + 1.11 (2019-08-11) + + 1.10 (2019-02-07) + support utf8 filenames in Windows; fix warnings and platform ifdefs + 1.09 (2018-02-11) + fix typo in zlib quality API, improve STB_I_W_STATIC in C++ + 1.08 (2018-01-29) + add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter + 1.07 (2017-07-24) + doc fix + 1.06 (2017-07-23) + writing JPEG (using Jon Olick's code) + 1.05 ??? + 1.04 (2017-03-03) + monochrome BMP expansion + 1.03 ??? + 1.02 (2016-04-02) + avoid allocating large structures on the stack + 1.01 (2016-01-16) + STBIW_REALLOC_SIZED: support allocators with no realloc support + avoid race-condition in crc initialization + minor compile issues + 1.00 (2015-09-14) + installable file IO function + 0.99 (2015-09-13) + warning fixes; TGA rle support + 0.98 (2015-04-08) + added STBIW_MALLOC, STBIW_ASSERT etc + 0.97 (2015-01-18) + fixed HDR asserts, rewrote HDR rle logic + 0.96 (2015-01-17) + add HDR output + fix monochrome BMP + 0.95 (2014-08-17) + add monochrome TGA output + 0.94 (2014-05-31) + rename private functions to avoid conflicts with stb_image.h + 0.93 (2014-05-27) + warning fixes + 0.92 (2010-08-01) + casts to unsigned char to fix warnings + 0.91 (2010-07-17) + first public release + 0.90 first internal release +*/ + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/src/common.h b/src/common.h new file mode 100644 index 0000000..930f9e8 --- /dev/null +++ b/src/common.h @@ -0,0 +1,75 @@ + +/************************************************************ +Title : A Photo-realistic Renderer Based on Photon Mapping +Students : Davood Rasti + Alireza Rasti + +Version : 0.01 +Date : 23-06-2012 +Updated : 01-10-2026 +*************************************************************/ + +#pragma once + +#include +#include +#include + +namespace PRRPM +{ + // typedef---------------------------------------- + using i8 = std::int8_t; + using ui8 = std::uint8_t; + using i16 = std::int16_t; + using ui16 = std::uint16_t; + using i32 = std::int32_t; + using ui32 = std::uint32_t; + using i64 = std::int64_t; + using ui64 = std::uint64_t; + using f32 = float; + using pchar = char*; + //----------------------------------------------- + + namespace MathUtility + { + inline constexpr f32 PI = 3.141592654f; + inline constexpr f32 HalfPI = 1.5708f; + inline constexpr f32 TwoPI = 6.28319f; + inline constexpr f32 DegreeToRadianCoefficient = PI / 180.0f; + inline constexpr f32 RadianToDegreeCoefficient = 180.0f / PI; + inline constexpr f32 InverstPI = 1.0f / PI; + + inline f32 degreeToRadian(f32 degree) + { + return degree * DegreeToRadianCoefficient; + } + + inline f32 radianToDegree(f32 radian) + { + return radian * RadianToDegreeCoefficient; + } + + inline f32 minValue(f32 value1, f32 value2) + { + return value1 < value2 ? value1 : value2; + } + + inline f32 maxValue(f32 value1, f32 value2) + { + return value1 > value2 ? value1 : value2; + } + + inline f32 clamp(f32 value, f32 lowValue, f32 highValue) + { + return maxValue(minValue(value, highValue), lowValue); + } + + inline void swap(f32& value1, f32& value2) + { + f32 tempValue = value1; + value1 = value2; + value2 = tempValue; + } + } // namespace MathUtility + +}; // namespace PRRPM \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..c43b245 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,810 @@ + +/************************************************************ +Title : A Photo-realistic Renderer Based on Photon Mapping +Students : Davood Rasti + Alireza Rasti + +Version : 0.01 +Date : 23-06-2012 +Updated : 01-10-2026 +*************************************************************/ + +#include "./3rdparty/stb_collection/stb_image_write.h" +#include "./prrpm.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace PRRPM; + +// Parse a complete numeric token so malformed scene values cannot silently become zero. +template Value parseNumber(std::string_view token) +{ + Value value{}; + const char* tokenEnd = token.data() + token.size(); + const auto result = std::from_chars(token.data(), tokenEnd, value); + if (result.ec != std::errc{} || result.ptr != tokenEnd) + throw std::invalid_argument("invalid numeric value '" + std::string(token) + "'"); + return value; +} + +std::vector tokenizer(const std::string& line) +{ + std::vector stringList; + std::string normalizedLine = line; + // Scene files accept whitespace as well as '=', ',' and ';' as separators. + for (char& character : normalizedLine) + { + if (character == '=' || character == ',' || character == ';') + character = ' '; + } + + std::istringstream lineStream(normalizedLine); + std::string token; + while (lineStream >> token) + stringList.push_back(token); + + return stringList; +} + +bool loadSceneFile(const std::string& fileName) +{ + std::ifstream modelFile(fileName); + if (!modelFile) + { + std::cerr << "Unable to open scene file: " << fileName << '\n'; + return false; + } + + std::string code; + PRRPM::Triangle triangle; + PRRPM::Sphere sphere; + + std::string lineToRead; + std::size_t lineNumber = 0; + while (std::getline(modelFile, lineToRead)) + { + ++lineNumber; + try + { + std::vector stringList; + stringList = tokenizer(lineToRead); + + if (stringList.size() < 1) + continue; + + code = stringList[0]; + + if (code[0] == '*') + break; + else if (code[0] == '/') + continue; + // Each non-comment line begins with a directive such as imagesize, light, t, or s. + else if (code == "imagesize" && stringList.size() >= 3) + { + imageWidth = parseNumber(stringList[1]); + imageHeight = parseNumber(stringList[2]); + } + else if (code == "light" && stringList.size() >= 2) + { + if (stringList[1] == "on" || stringList[1] == "off") + isLightOn = stringList[1] == "on"; + // Accept either the full numeric light record or the compact "light pos" form. + else if (stringList.size() >= 11) + { + PRRPM::LightSource lightSource{}; + lightSource.type = parseNumber(stringList[1]); + lightSource.position = + Vector3d(parseNumber(stringList[2]), parseNumber(stringList[3]), + parseNumber(stringList[4])); + lightSource.intensity = + Vector3d(parseNumber(stringList[5]), parseNumber(stringList[6]), + parseNumber(stringList[7])); + lightSource.size = + Vector3d(parseNumber(stringList[8]), parseNumber(stringList[9]), + parseNumber(stringList[10])); + lightSourcesList.push_back(lightSource); + } + else if (stringList[1] == "pos" && stringList.size() >= 5) + { + PRRPM::LightSource lightSource{}; + lightSource.type = 0; + lightSource.position = + Vector3d(parseNumber(stringList[2]), parseNumber(stringList[3]), + parseNumber(stringList[4])); + lightSource.intensity = Vector3d(1.0f, 1.0f, 1.0f); + lightSourcesList.push_back(lightSource); + } + } + else if ((code == "numberOfPhotons" || code == "numberOfPhotonPass" || + code == "numberOfBounces" || code == "numberOfPhotonBounces") && + stringList.size() >= 2) + { + const ui32 value = parseNumber(stringList[1]); + if (code == "numberOfPhotons") + numberOfPhotons = value; + else if (code == "numberOfPhotonPass") + numberOfPhotonPass = value; + else + numberOfBounces = value; + } + else if (code == "photonCasting" && stringList.size() >= 2) + isPhotonMapping = stringList[1] == "on"; + else if (code == "gui" && stringList.size() >= 2) + { + if (stringList[1] == "off") + isGUI = false; + else if (stringList[1] == "on") + isGUI = true; + } + else if (code == "t" && stringList.size() >= 13) + { + triangle.point1.x = parseNumber(stringList[1]); + triangle.point1.y = parseNumber(stringList[2]); + triangle.point1.z = parseNumber(stringList[3]); + + triangle.point2.x = parseNumber(stringList[4]); + triangle.point2.y = parseNumber(stringList[5]); + triangle.point2.z = parseNumber(stringList[6]); + + triangle.point3.x = parseNumber(stringList[7]); + triangle.point3.y = parseNumber(stringList[8]); + triangle.point3.z = parseNumber(stringList[9]); + + triangle.color.x = parseNumber(stringList[10]); + triangle.color.y = parseNumber(stringList[11]); + triangle.color.z = parseNumber(stringList[12]); + + triangle.materialID = + stringList.size() >= 14 ? parseNumber(stringList[13]) : 0; + + // The ray-triangle test uses the precomputed face normal. + PRRPM::Vector3d edge1 = triangle.point2 - triangle.point1; + PRRPM::Vector3d edge2 = triangle.point3 - triangle.point1; + triangle.normal = edge1.cross(edge2); + triangle.normal.normalize(); + + triangleList.push_back(triangle); + } + else if (code == "s" && stringList.size() >= 8) + { + sphere.position.x = parseNumber(stringList[1]); + sphere.position.y = parseNumber(stringList[2]); + sphere.position.z = parseNumber(stringList[3]); + + sphere.radius = parseNumber(stringList[4]); + + sphere.color.x = parseNumber(stringList[5]); + sphere.color.y = parseNumber(stringList[6]); + sphere.color.z = parseNumber(stringList[7]); + + sphere.materialID = stringList.size() >= 9 ? parseNumber(stringList[8]) : 0; + + sphereList.push_back(sphere); + } + } + catch (const std::invalid_argument& error) + { + // Include the source location so scene-file typos are easy to find. + std::cerr << fileName << ':' << lineNumber << ": " << error.what() << '\n'; + return false; + } + } + + return true; +} + +// Advance one queued secondary ray. Status values are -2 (finished), 0 (diffuse), +// 1 (mirror), and 2 (dielectric); storing these states makes recursion unnecessary. +void nextRayTracingPass(ui32 index) +{ + + if (secondIntersectionPointsList[index].nubmerOfPhotonAndMaterialID == -2) + return; + + PRRPM::Ray ray; + ray.direction = secondIntersectionPointsList[index].fluxAndDirection; + ray.direction.normalize(); + ray.origin = secondIntersectionPointsList[index].positionAndOrigin; + ray.objectID = -1; + ray.distance = maxSceneDepth; + + PRRPM::Vector3d color; + intersectObjects(&ray); + if (ray.objectID != -1) + { + if (getObjectMaterial(ray.objectID, ray.objectType) == 0) + { + if (secondIntersectionPointsList[index].radiusSquare != -1) + color = getObjectColor(ray.objectID, ray.objectType); + else + color = secondIntersectionPointsList[index].color * + getObjectColor(ray.objectID, ray.objectType); + + int cellID = computeCellID(ray.intersectionPosition); + if (cellID >= 0 && cellID < gridSize) + { + secondIntersectionPointsList[index].color = color; + secondIntersectionPointsList[index].positionAndOrigin = ray.intersectionPosition; + secondIntersectionPointsList[index].normal = getSurfaceNormal(ray); + secondIntersectionPointsList[index].cellID = cellID; + // secondIntersectionPointsList[index].materialID = 0; + + secondIntersectionPointsList[index].radiusSquare = irridianceRadiusSquare; + secondIntersectionPointsList[index].nubmerOfPhotonAndMaterialID = 0; + secondIntersectionPointsList[index].fluxAndDirection = PRRPM::Vector3d(); + } + } + else if (getObjectMaterial(ray.objectID, ray.objectType) == 1) + { + PRRPM::Vector3d normal = getSurfaceNormal(ray); + secondIntersectionPointsList[index].positionAndOrigin = ray.intersectionPosition; + secondIntersectionPointsList[index].fluxAndDirection = + ray.direction - normal * normal.dot(ray.direction) * 2.0f; + secondIntersectionPointsList[index].nubmerOfPhotonAndMaterialID = 1; + } + else if (getObjectMaterial(ray.objectID, ray.objectType) == 2) + { + secondIntersectionPointsList[index].positionAndOrigin = ray.intersectionPosition; + secondIntersectionPointsList[index].normal = getSurfaceNormal(ray); + secondIntersectionPointsList[index].fluxAndDirection = ray.direction; + + if (secondIntersectionPointsList[index].radiusSquare == -1) + secondIntersectionPointsList[index].color = + secondIntersectionPointsList[index].color * + getObjectColor(ray.objectID, ray.objectType); + else + secondIntersectionPointsList[index].color = + getObjectColor(ray.objectID, ray.objectType); + secondIntersectionPointsList[index].nubmerOfPhotonAndMaterialID = 2; + } + } + else + secondIntersectionPointsList[index].nubmerOfPhotonAndMaterialID = -2; +} + +// Replace each dielectric hit with its reflected and refracted paths, then discard finished paths. +void calculateReflectionFractionForAllPoints() +{ + PRRPM::ui32 step = 0; + for (PRRPM::ui32 iPoint = 0; iPoint < secondIntersectionPointsList.size(); ++iPoint) + { + IntersectionPoint intersectionPoint = secondIntersectionPointsList[iPoint]; + if (intersectionPoint.nubmerOfPhotonAndMaterialID == 2) + { + PRRPM::Vector3d reflectionRayDirection; + PRRPM::Vector3d refractionRayDirection; + f32 cosOutAngle; + f32 reflectionIntensity; + + ++step; + + calculateReflectionFractionDirection(intersectionPoint.fluxAndDirection, + intersectionPoint.normal, &reflectionRayDirection, + &refractionRayDirection, &cosOutAngle, + &reflectionIntensity); + if (cosOutAngle < 0) + { + secondIntersectionPointsList[iPoint] = intersectionPoint; + secondIntersectionPointsList[iPoint].fluxAndDirection = reflectionRayDirection; + secondIntersectionPointsList[iPoint].radiusSquare = -1; + ++iPoint; + continue; + } + + secondIntersectionPointsList[iPoint - 1] = intersectionPoint; + secondIntersectionPointsList[iPoint - 1].fluxAndDirection = refractionRayDirection; + secondIntersectionPointsList[iPoint - 1].color = + secondIntersectionPointsList[iPoint].color * (1.0 - reflectionIntensity); + secondIntersectionPointsList[iPoint - 1].radiusSquare = -1; + + secondIntersectionPointsList[iPoint] = intersectionPoint; + secondIntersectionPointsList[iPoint].fluxAndDirection = reflectionRayDirection; + // secondIntersectionPointsList[iPoint].nubmerOfPhotonAndMaterialID = -2; + secondIntersectionPointsList[iPoint].color = + secondIntersectionPointsList[iPoint].color * reflectionIntensity; + secondIntersectionPointsList[iPoint].radiusSquare = -1; + } + } + + std::sort(secondIntersectionPointsList.begin(), secondIntersectionPointsList.end(), + compareByMetalID); + PRRPM::ui32 numberOfNonDiffusedPoint = int(std::count_if( + secondIntersectionPointsList.begin(), secondIntersectionPointsList.end(), isMetalIDOut)); + secondIntersectionPointsList.erase(secondIntersectionPointsList.begin(), + secondIntersectionPointsList.begin() + + numberOfNonDiffusedPoint); +} + +// Cast one primary camera ray per pixel. Diffuse hits are photon-map gather points; +// mirror and dielectric hits are queued for the later non-recursive passes. +void firstRayTracingPass() +{ + PRRPM::f32 screenRatio = (PRRPM::f32)imageWidth / (PRRPM::f32)imageHeight; + PRRPM::f32 inverseWidth = 1.0f / (PRRPM::f32)imageWidth; + PRRPM::f32 inverseHeight = 1.0f / (PRRPM::f32)imageHeight; + PRRPM::f32 inverseWidthOverTwo = inverseWidth / 4.0f; + PRRPM::f32 inverseHeightOverTwo = inverseHeight / 2.0f; + + for (ui32 y = 0; y < imageHeight; ++y) + { + Ray ray; + unsigned int yPixel = y * imageWidth; + + for (ui32 x = 0; x < imageWidth; ++x) + { + + ray.direction.x = ((x + inverseWidthOverTwo) * inverseWidth - 0.5) * screenRatio; + ray.direction.y = ((y + inverseHeightOverTwo) * inverseHeight - 0.5); + ray.direction.z = screenRatio; + ray.direction.normalize(); + ray.origin = Vector3d(0.0, 0.0, 0.0); + ray.objectID = -1; + ray.distance = maxSceneDepth; + + intersectObjects(&ray); + if (ray.objectID != -1) + { + PRRPM::ui32 index = x + (y * imageWidth); + if (getObjectMaterial(ray.objectID, ray.objectType) == 0) + { + PRRPM::Vector3d color = getObjectColor(ray.objectID, ray.objectType); + int cellID = computeCellID(ray.intersectionPosition); + if (cellID >= 0 && cellID < gridSize) + { + intersectionPointsList[index].color = color; + intersectionPointsList[index].positionAndOrigin = ray.intersectionPosition; + intersectionPointsList[index].normal = getSurfaceNormal(ray); + intersectionPointsList[index].pixelIndex = x + yPixel; + intersectionPointsList[index].cellID = cellID; + // intersectionPointsList[index].materialID = 0; + + intersectionPointsList[index].radiusSquare = irridianceRadiusSquare; + intersectionPointsList[index].nubmerOfPhotonAndMaterialID = 0; + intersectionPointsList[index].fluxAndDirection = Vector3d(); + } + } + else if (getObjectMaterial(ray.objectID, ray.objectType) == 1) + { + PRRPM::Vector3d normal = getSurfaceNormal(ray); + intersectionPointsList[index].positionAndOrigin = ray.intersectionPosition; + intersectionPointsList[index].fluxAndDirection = + ray.direction - normal * normal.dot(ray.direction) * 2.0f; + intersectionPointsList[index].pixelIndex = x + yPixel; + intersectionPointsList[index].nubmerOfPhotonAndMaterialID = 1; + } + else if (getObjectMaterial(ray.objectID, ray.objectType) == 2) + { + intersectionPointsList[index].positionAndOrigin = ray.intersectionPosition; + intersectionPointsList[index].normal = getSurfaceNormal(ray); + intersectionPointsList[index].pixelIndex = x + yPixel; + intersectionPointsList[index].fluxAndDirection = ray.direction; + intersectionPointsList[index].color = + getObjectColor(ray.objectID, ray.objectType); + intersectionPointsList[index].nubmerOfPhotonAndMaterialID = 2; + } + } + } + } +} + +void prepareIntersectionPointsList() +{ + // -1 cell/pixel indices mark pixels that did not produce a valid gather point. + intersectionPointsList.resize((imageWidth * imageHeight)); + PRRPM::IntersectionPoint intersectionPoint; + intersectionPoint.color = PRRPM::Vector3d(); + intersectionPoint.positionAndOrigin = PRRPM::Vector3d(); + intersectionPoint.normal = PRRPM::Vector3d(); + intersectionPoint.pixelIndex = -1; + intersectionPoint.cellID = -1; + intersectionPoint.radiusSquare = irridianceRadiusSquare; + intersectionPoint.nubmerOfPhotonAndMaterialID = 0; + intersectionPoint.fluxAndDirection = PRRPM::Vector3d(); + std::fill(intersectionPointsList.begin(), + intersectionPointsList.begin() + (imageWidth * imageHeight), intersectionPoint); +} + +void rayTracingPass() +{ + firstRayTracingPass(); + + for (ui32 iPoint = 0; iPoint < intersectionPointsList.size(); ++iPoint) + { + if (intersectionPointsList[iPoint].nubmerOfPhotonAndMaterialID != 0) + { + PRRPM::IntersectionPoint intersectionPoint = intersectionPointsList[iPoint]; + intersectionPoint.nubmerOfPhotonAndMaterialID = -2; + secondIntersectionPointsList.push_back(intersectionPoint); + secondIntersectionPointsList.push_back(intersectionPointsList[iPoint]); + } + } + + // Seed the work list with secondary paths, then advance it a fixed number of bounces. + calculateReflectionFractionForAllPoints(); + + for (ui32 iBounce = 1; iBounce < 5; ++iBounce) + { + for (ui32 iPoints = 0; iPoints < secondIntersectionPointsList.size(); ++iPoints) + nextRayTracingPass(iPoints); + + for (ui32 iPoint = 0; iPoint < secondIntersectionPointsList.size(); ++iPoint) + { + if (secondIntersectionPointsList[iPoint].nubmerOfPhotonAndMaterialID == 0) + intersectionPointsList.push_back(secondIntersectionPointsList[iPoint]); + } + + std::sort(secondIntersectionPointsList.begin(), secondIntersectionPointsList.end(), + compareByCellID); + ui32 numberOfNonDiffusedPoint = int(std::count_if( + secondIntersectionPointsList.begin(), secondIntersectionPointsList.end(), isCellIDOut)); + secondIntersectionPointsList.erase( + secondIntersectionPointsList.end() - + (secondIntersectionPointsList.size() - numberOfNonDiffusedPoint), + secondIntersectionPointsList.end()); + + std::vector tempsecondIntersectionPointsList; + for (ui32 iPoint = 0; iPoint < secondIntersectionPointsList.size(); ++iPoint) + { + PRRPM::IntersectionPoint intersectionPoint; + intersectionPoint.nubmerOfPhotonAndMaterialID = -2; + tempsecondIntersectionPointsList.push_back(intersectionPoint); + tempsecondIntersectionPointsList.push_back(secondIntersectionPointsList[iPoint]); + } + + secondIntersectionPointsList.clear(); + secondIntersectionPointsList = tempsecondIntersectionPointsList; + calculateReflectionFractionForAllPoints(); + } +} + +void findPointAndComputeFlux(const Ray& photonRay, const PRRPM::Vector3d& color) +{ + // Gather this photon into nearby camera gather points and shrink their radii as they + // accumulate. + PRRPM::Vector3d surfaceNormal = getSurfaceNormal(photonRay); + for (std::size_t iNeighbor = 0; iNeighbor < std::size(neighborsDirection); ++iNeighbor) + { + int cellID = computeCellID(photonRay.intersectionPosition + neighborsDirection[iNeighbor]); + if (cellID < 0 || cellID >= gridSize) + continue; + + const int firstCell = hastValueList[cellID]; + if (firstCell >= 0) + { + std::size_t pointIndex = static_cast(firstCell); + while (true) + { + + Vector3d distanceVector = intersectionPointsList[pointIndex].positionAndOrigin - + photonRay.intersectionPosition; + f32 distance = distanceVector.dot(distanceVector); + IntersectionPoint* intersectionPoint = &intersectionPointsList[pointIndex]; + f32 dotNormals = intersectionPoint->normal.dot(surfaceNormal); + if (dotNormals > -0.001 && distance <= intersectionPoint->radiusSquare) + { + f32 radiusReductionCoefficient = + (intersectionPointsList[pointIndex].nubmerOfPhotonAndMaterialID * alpha + + alpha) / + (intersectionPoint->nubmerOfPhotonAndMaterialID * alpha + 1.0); + intersectionPoint->radiusSquare *= radiusReductionCoefficient; + ++intersectionPoint->nubmerOfPhotonAndMaterialID; + intersectionPoint->fluxAndDirection = + (intersectionPoint->fluxAndDirection + + intersectionPoint->color * color * MathUtility::InverstPI) * + radiusReductionCoefficient; + } + ++pointIndex; + if (pointIndex >= intersectionPointsList.size() || + intersectionPointsList[pointIndex].cellID != cellID) + break; + } + } + } +} + +void photonCasting(std::default_random_engine& randomNumberGenerator, + const LightSource& lightSource) +{ + std::uniform_real_distribution uniform(0.0, 1.0); + + PRRPM::Ray photonRay; + generatePhotonRayFromLighSource(&photonRay, lightSource, randomNumberGenerator); + photonRay.objectID = -1; + photonRay.distance = maxSceneDepth; + + ui8 bounces = 0; + Vector3d color = lightSource.intensity; + bool isRefraction = false; + while (true) + { + intersectObjects(&photonRay); + if (photonRay.objectID != -1) + { + Vector3d objectColor = getObjectColor(photonRay.objectID, photonRay.objectType); + ui8 objectMaterialID = getObjectMaterial(photonRay.objectID, photonRay.objectType); + if (objectMaterialID == 0) + { + // Diffuse hits contribute flux; the next direction is sampled from the hemisphere. + findPointAndComputeFlux(photonRay, color); + ++bounces; + f32 reflectionProbability = + std::max(objectColor.x, std::max(objectColor.y, objectColor.z)); + if (bounces >= numberOfBounces || + (bounces > 1 && uniform(randomNumberGenerator) <= reflectionProbability)) + break; + + if (isRefraction) + { + color = lightSource.intensity; + isRefraction = false; + } + else + color = color * getObjectColor(photonRay.objectID, photonRay.objectType) / + reflectionProbability; // * 0.7f; + + f32 r1 = MathUtility::TwoPI * uniform(randomNumberGenerator); + f32 r2 = uniform(randomNumberGenerator); + f32 r2s = sqrtf(r2); + PRRPM::Vector3d tempNormal = getSurfaceNormal(photonRay); + if (tempNormal.dot(photonRay.direction) >= 0) + tempNormal = tempNormal * -1.0f; + PRRPM::Vector3d w = tempNormal; + PRRPM::Vector3d u = PRRPM::Vector3d(1, 0, 0); + + if (fabs(w.x) > 0.1) + u = PRRPM::Vector3d(0, 1, 0); + + u = u.cross(w); + u.normalize(); + PRRPM::Vector3d v = w.cross(u); + photonRay.direction = + u * cosf(r1) * r2s + v * sinf(r1) * r2s + w * sqrtf(1.0f - r2); + photonRay.direction.normalize(); + + photonRay.origin = photonRay.intersectionPosition; + photonRay.objectID = -1; + photonRay.distance = maxSceneDepth; + continue; + } + else if (objectMaterialID == 1) + { + // Mirror material: reflect the photon and continue its path. + PRRPM::Vector3d normal = getSurfaceNormal(photonRay); + photonRay.direction = + photonRay.direction - normal * normal.dot(photonRay.direction) * 2.0; + photonRay.origin = photonRay.intersectionPosition; + photonRay.objectID = -1; + photonRay.distance = maxSceneDepth; + ++bounces; + if (bounces >= numberOfBounces) + break; + + continue; + } + else if (objectMaterialID == 2) + { + // Dielectric material: choose reflection or refraction using Fresnel probability. + + PRRPM::Vector3d reflectionRayDirection; + PRRPM::Vector3d refractionRayDirection; + f32 cosOutAngle; + f32 reflectionIntensity; + calculateReflectionFractionDirection( + photonRay.direction, getSurfaceNormal(photonRay), &reflectionRayDirection, + &refractionRayDirection, &cosOutAngle, &reflectionIntensity); + if (cosOutAngle < 0) + { + photonRay.origin = photonRay.intersectionPosition; + photonRay.direction = reflectionRayDirection; + photonRay.objectID = -1; + photonRay.distance = maxSceneDepth; + ++bounces; + if (bounces >= numberOfBounces) + break; + + continue; + } + + photonRay.origin = photonRay.intersectionPosition; + if (uniform(randomNumberGenerator) >= reflectionIntensity) + { + photonRay.direction = refractionRayDirection; + color = getObjectColor(photonRay.objectID, photonRay.objectType) * + lightSource.intensity; + } + else + { + photonRay.direction = reflectionRayDirection; + color = getObjectColor(photonRay.objectID, photonRay.objectType); + } + photonRay.objectID = -1; + photonRay.distance = maxSceneDepth; + isRefraction = true; + ++bounces; + if (bounces >= numberOfBounces) + break; + + continue; + } + else + break; + } + else + break; + } +} + +void photonCastingPass() +{ + if (lightSourcesList.empty()) + { + std::cerr << "No light sources defined in the scene\n"; + return; + } + + // Each pass launches a fresh set of photons; progress is updated in place on the console. + for (ui32 iPhotonPass = 0; iPhotonPass < numberOfPhotonPass; ++iPhotonPass) + { + std::default_random_engine randomNumberGenerator; + for (ui32 iPhoton = 0; iPhoton < numberOfPhotons; ++iPhoton) + { + LightSource lightSource = lightSourcesList[iPhoton % lightSourcesList.size()]; + photonCasting(randomNumberGenerator, lightSource); + } + + std::cout << "\rPass: " << iPhotonPass + 1 << '/' << numberOfPhotonPass << std::flush; + } + std::cout << '\n'; +} + +// Build the spatial hash table for efficient photon gathering. +void buildHashTable() +{ + // Sort gather points by cell so each hash entry can point to the start of its cell's range. + std::sort(intersectionPointsList.begin(), intersectionPointsList.end(), compareByCellID); + PRRPM::ui32 numberOfNonDiffusedPoint = int( + std::count_if(intersectionPointsList.begin(), intersectionPointsList.end(), isCellIDOut)); + intersectionPointsList.erase(intersectionPointsList.begin(), + intersectionPointsList.begin() + numberOfNonDiffusedPoint); + + hastValueList.resize(gridSize); + std::fill(hastValueList.begin(), hastValueList.begin() + gridSize, -1); + + for (std::size_t i = 0; i < intersectionPointsList.size(); ++i) + { + const int cellID = intersectionPointsList[i].cellID; + if (hastValueList[cellID] == -1) + hastValueList[cellID] = i; + } +} + +// Correct the flux at each gather point to compute the final irradiance. +void fluxCorrection() +{ + // Convert accumulated photon flux to irradiance using each gather point's final disk area. + imageBufferList.resize((imageWidth * imageHeight)); + std::fill(imageBufferList.begin(), imageBufferList.begin() + (imageWidth * imageHeight), + Vector3d(0, 0, 0)); + + for (std::size_t i = 0; i < intersectionPointsList.size(); ++i) + { + const int pixelIndex = intersectionPointsList[i].pixelIndex; + imageBufferList[pixelIndex] = + imageBufferList[pixelIndex] + + intersectionPointsList[i].fluxAndDirection * + (1.0 / (MathUtility::PI * intersectionPointsList[i].radiusSquare * numberOfPhotons * + numberOfPhotonPass)); + } +} + +void saveImage(void) +{ + const std::size_t expectedPixelCount = static_cast(imageWidth) * imageHeight; + if (imageBufferList.size() != expectedPixelCount) + { + std::cerr << "Image buffer size does not match image dimensions\n"; + return; + } + + // Convert linear floating-point RGB into display-encoded 8-bit RGB for the BMP writer. + std::vector pixels(imageBufferList.size() * 3); + const auto toByte = [](f32 channel) + { + channel = std::clamp(channel, 0.0f, 1.0f); + const f32 srgb = channel <= 0.0031308f ? 12.92f * channel + : 1.055f * std::pow(channel, 1.0f / 2.4f) - 0.055f; + return static_cast(std::lround(srgb * 255.0f)); + }; + + for (std::size_t y = 0; y < imageHeight; ++y) + { + // Camera rows increase upward; image files store the top row first. + const std::size_t sourceRow = imageHeight - 1 - y; + for (std::size_t x = 0; x < imageWidth; ++x) + { + const std::size_t sourceIndex = sourceRow * imageWidth + x; + const std::size_t targetIndex = (y * imageWidth + x) * 3; + pixels[targetIndex] = toByte(imageBufferList[sourceIndex].x); + pixels[targetIndex + 1] = toByte(imageBufferList[sourceIndex].y); + pixels[targetIndex + 2] = toByte(imageBufferList[sourceIndex].z); + } + } + + if (!stbi_write_bmp(outFileName.c_str(), static_cast(imageWidth), + static_cast(imageHeight), 3, pixels.data())) + std::cerr << "Failed to write image: " << outFileName << '\n'; +} + +void cleanUp(void) +{ + // delete[] imageBuffer; +} + +void displayItroAndInfo(void) +{ + std::cout << " Scene Information"; + std::cout << "\n Number of triangles : " << triangleList.size(); + std::cout << "\n Light : "; + if (isLightOn) + std::cout << "on"; + else + std::cout << "off"; + std::cout << "\n Image size : " << imageWidth << " X " << imageHeight; + std::cout << "\n Output file : " << outFileName << "\n\n"; +} + +int main(int argc, char* argv[]) +{ + if (argc != 3) + { + std::cerr << "Usage: " << argv[0] << " \n"; + return 1; + } + + const std::filesystem::path sceneFilePath = argv[1]; + outFileName = argv[2]; + + if (!loadSceneFile(sceneFilePath.string())) + return 1; + + displayItroAndInfo(); + + // Pipeline: trace camera paths, build the photon lookup table, cast photons, then write output. + const auto renderingStart = std::chrono::steady_clock::now(); + + prepareIntersectionPointsList(); + + std::cout << "raytracing:1:start\n"; + rayTracingPass(); + std::cout << "raytracing:1:done\nphotontracing:start\n"; + + buildHashTable(); + + photonCastingPass(); + + std::cout << "photontracing:done\n"; + + // return 0; + + fluxCorrection(); + + const auto renderingEnd = std::chrono::steady_clock::now(); + const double totalRenderingTime = + std::chrono::duration(renderingEnd - renderingStart).count(); + std::cout << "renderingtime:" << totalRenderingTime << std::endl; + + // Save result image buffer in file + saveImage(); + cleanUp(); + std::cout << "done\n"; + + return 0; +} \ No newline at end of file diff --git a/src/prrpm.cpp b/src/prrpm.cpp new file mode 100644 index 0000000..46afb22 --- /dev/null +++ b/src/prrpm.cpp @@ -0,0 +1,41 @@ +#include "prrpm.h" + +namespace PRRPM +{ + ui32 imageWidth = 800; + ui32 imageHeight = 800; + ui32 numberOfPhotons = 1000; + ui32 numberOfPhotonPass = 1000; + ui32 numberOfBounces = 5; + std::string outFileName = "output.bmp"; + std::vector imageBufferList; + bool isLightOn = true; + bool isPhotonMapping = true; + bool isGUI = true; + + Vector3d neighborsDirection[27] = { + Vector3d(0.0, 0.0, 0.0), Vector3d(0.004, 0.0, 0.0), + Vector3d(-0.004, 0.0, 0.0), Vector3d(0.0, 0.004, 0.0), + Vector3d(0.0, -0.004, 0.0), Vector3d(0.004, 0.004, 0.0), + Vector3d(-0.004, 0.004, 0.0), Vector3d(0.004, -0.004, 0.0), + Vector3d(-0.004, -0.004, 0.0), + + Vector3d(0.004, 0.0, 0.004), Vector3d(-0.004, 0.0, 0.004), + Vector3d(0.0, 0.004, 0.004), Vector3d(0.0, -0.004, 0.004), + Vector3d(0.004, 0.004, 0.004), Vector3d(-0.004, 0.004, 0.004), + Vector3d(0.004, -0.004, 0.004), Vector3d(-0.004, -0.004, 0.004), + + Vector3d(0.004, 0.0, -0.004), Vector3d(-0.004, 0.0, -0.004), + Vector3d(0.0, 0.004, -0.004), Vector3d(0.0, -0.004, -0.004), + Vector3d(0.004, 0.004, -0.004), Vector3d(-0.004, 0.004, -0.004), + Vector3d(0.004, -0.004, -0.004), Vector3d(-0.004, -0.004, -0.004), + + Vector3d(0.0, 0.0, -0.004), Vector3d(0.0, 0.0, 0.004)}; + + std::vector triangleList; + std::vector sphereList; + std::vector lightSourcesList; + std::vector intersectionPointsList; + std::vector secondIntersectionPointsList; + std::vector hastValueList; +} // namespace PRRPM \ No newline at end of file diff --git a/src/prrpm.h b/src/prrpm.h new file mode 100644 index 0000000..64374b0 --- /dev/null +++ b/src/prrpm.h @@ -0,0 +1,322 @@ + +/************************************************************ +Title : A Photo-realistic Renderer Based on Photon Mapping +Students : Davood Rasti + Alireza Rasti + +Version : 0.01 +Date : 23-06-2012 +Updated : 01-10-2026 +*************************************************************/ + +#pragma once + +#include "./3rdparty/stb_collection/stb_image.h" +#include "vector3d.h" +#include +#include +#include +#include +#include + +namespace PRRPM +{ + + // Structures + struct Ray + { + Vector3d origin; + Vector3d direction; + int objectID; + ui32 objectType; + Vector3d intersectionPosition; + f32 distance; + }; + + struct Triangle + { + Vector3d point1; + Vector3d point2; + Vector3d point3; + Vector3d color; + Vector3d normal; + ui8 materialID; + }; + + struct Sphere + { + Vector3d position; + float radius; + Vector3d color; + ui32 numberOfSpheres; + ui8 materialID; + }; + + struct IntersectionPoint + { + Vector3d color; + Vector3d positionAndOrigin; + Vector3d normal; + Vector3d fluxAndDirection; + f32 radiusSquare; + i32 nubmerOfPhotonAndMaterialID; + int pixelIndex; + int cellID; + }; + + struct LightSource + { + ui8 type; + Vector3d position; + Vector3d intensity; + Vector3d size; + }; + + extern ui32 imageWidth; + extern ui32 imageHeight; + extern ui32 numberOfPhotons; + extern ui32 numberOfPhotonPass; + extern ui32 numberOfBounces; + inline constexpr f32 maxSceneDepth = 1000.0f; + inline constexpr f32 alpha = 0.7f; + extern std::string outFileName; + extern std::vector imageBufferList; + extern bool isLightOn; + extern bool isPhotonMapping; + extern bool isGUI; + inline constexpr f32 refractiveIndexIn = 1.0f; + inline constexpr f32 refractiveIndexOut = 1.5f; + + inline constexpr int gridSize = 16000000; + inline constexpr f32 irridianceRadiusSquare = 0.000016f; + inline constexpr int numberOfGridCell = 250; + inline constexpr int numberOfGridCellXY = 252; + inline constexpr int numberOfGridCellXMY = 63000; + + extern Vector3d neighborsDirection[27]; + extern std::vector triangleList; + extern std::vector sphereList; + extern std::vector lightSourcesList; + extern std::vector intersectionPointsList; + extern std::vector secondIntersectionPointsList; + extern std::vector hastValueList; + + inline bool compareByCellID(const IntersectionPoint& firstPoint, + const IntersectionPoint& secondPoint) + { + return (firstPoint.cellID < secondPoint.cellID); + } + + inline bool compareByMetalID(const IntersectionPoint& firstPoint, + const IntersectionPoint& secondPoint) + { + return (firstPoint.nubmerOfPhotonAndMaterialID < secondPoint.nubmerOfPhotonAndMaterialID); + } + + inline bool isCellIDOut(const IntersectionPoint& point) + { + return (point.cellID == -1); + } + + inline bool isMetalIDOut(const IntersectionPoint& point) + { + return (point.nubmerOfPhotonAndMaterialID == -2); + } + + inline int computeCellID(const Vector3d& position) + { + int x = (position.x + 0.6) * numberOfGridCell; + int y = (position.y + 0.6) * numberOfGridCell; + int z = (position.z - 1.0) * numberOfGridCell; + return (z * numberOfGridCellXMY + y * numberOfGridCellXY + x); + } + + inline void generatePhotonRayFromLighSource(Ray* ray, const LightSource& lightSource, + std::default_random_engine& randomNumberGenerator) + { + std::uniform_real_distribution uniform(0.0, 1.0); + + if (lightSource.type == 0) + { + f32 u = MathUtility::TwoPI * uniform(randomNumberGenerator); + f32 v = acosf(sqrtf(uniform(randomNumberGenerator))) * 2.0; + f32 w = sinf(v); + ray->direction = Vector3d(cosf(u) * w, cosf(v), sinf(u) * w); + ray->origin = lightSource.position; + } + else if (lightSource.type == 1) + { + std::uniform_real_distribution uniformX(-lightSource.size.x, lightSource.size.x); + std::uniform_real_distribution uniformZ(-lightSource.size.z, lightSource.size.z); + std::uniform_real_distribution uniformNP(-1.0, 1.0); + + f32 u = uniform(randomNumberGenerator); + f32 v = MathUtility::TwoPI * uniform(randomNumberGenerator); + f32 uSquare = sqrtf(u); + f32 x = cosf(v) * uSquare; + f32 y = sin(v) * uSquare; + f32 z = sqrtf(1.0 - u); + + ray->direction = Vector3d(x, -y, z * uniformNP(randomNumberGenerator)); + + ray->origin.x = uniformX(randomNumberGenerator); + ray->origin.y = 0; + ray->origin.z = uniformZ(randomNumberGenerator); + ray->origin = ray->origin + lightSource.position; + } + + ray->direction.normalize(); + } + + inline void intersectTriangle(Ray* ray, unsigned int triangleIndex) + { + + Vector3d edge1 = triangleList[triangleIndex].point2 - triangleList[triangleIndex].point1; + Vector3d edge2 = triangleList[triangleIndex].point3 - triangleList[triangleIndex].point1; + + Vector3d pVector = ray->direction.cross(edge2); + f32 determinat = edge1.dot(pVector); + + if (determinat < 0.000001) + return; + + Vector3d tVector = ray->origin - triangleList[triangleIndex].point1; + + f32 u = tVector.dot(pVector); + + if (u < 0.0 || u > determinat) + return; + + Vector3d qVector = tVector.cross(edge1); + + f32 v = ray->direction.dot(qVector); + + if (v < 0.0 || (u + v) > determinat) + return; + + float inverseDeterminat = 1.0f / determinat; + + float t = edge2.dot(qVector) * inverseDeterminat; + u *= inverseDeterminat; + v *= inverseDeterminat; + + ray->distance = t; + ray->intersectionPosition = triangleList[triangleIndex].point1 + (edge1 * u) + (edge2 * v); + } + + inline void intersectSphere(Ray* ray, unsigned int sphereIndex) + { + Vector3d dist = sphereList[sphereIndex].position - ray->origin; + f32 b = ray->direction.dot(dist); + f32 delta = b * b - dist.dot(dist) + + (sphereList[sphereIndex].radius * sphereList[sphereIndex].radius); + if (delta < 0.0f) + return; + f32 t0 = b - sqrt(delta); + f32 t1 = b + sqrt(delta); + f32 distance = maxSceneDepth; + if ((t0 > 0.001f) && (t0 < distance)) + distance = t0; + else if ((t1 > 0.001f) && (t1 < distance)) + distance = t1; + + ray->distance = distance; + } + + inline void intersectObjects(Ray* ray) + { + Ray tempRay; + tempRay.direction = ray->direction; + tempRay.origin = ray->origin; + tempRay.distance = maxSceneDepth; + ray->distance = maxSceneDepth; + + for (unsigned int iTriangle = 0; iTriangle < triangleList.size(); ++iTriangle) + { + intersectTriangle(&tempRay, iTriangle); + if (tempRay.distance < ray->distance) + { + ray->intersectionPosition = tempRay.intersectionPosition; + ray->objectID = iTriangle; + ray->objectType = 0; + ray->distance = tempRay.distance; + } + } + + tempRay.objectID = -1; + tempRay.distance = maxSceneDepth; + + for (unsigned int iSphere = 0; iSphere < sphereList.size(); ++iSphere) + { + intersectSphere(&tempRay, iSphere); + if (tempRay.distance < ray->distance) + { + ray->objectID = iSphere; + ray->objectType = 1; + ray->distance = tempRay.distance; + ray->intersectionPosition = (ray->direction * ray->distance) + ray->origin; + } + } + } + + inline Vector3d getSurfaceNormal(const Ray& ray) + { + Vector3d surfaceNormal; + if (ray.objectType == 0) + surfaceNormal = triangleList[ray.objectID].normal; + else + { + surfaceNormal = ray.intersectionPosition - sphereList[ray.objectID].position; + surfaceNormal.normalize(); + } + + return surfaceNormal; + } + + inline Vector3d getObjectColor(ui32 objectID, ui32 objectType) + { + if (objectType == 0) + return triangleList[objectID].color; + else + return sphereList[objectID].color; + } + + inline ui8 getObjectMaterial(ui32 objectID, ui32 objectType) + { + if (objectType == 0) + return triangleList[objectID].materialID; + else + return sphereList[objectID].materialID; + } + + inline void calculateReflectionFractionDirection(Vector3d rayDirection, Vector3d normal, + Vector3d* reflectionDirection, + Vector3d* refractionDirection, + f32* cosOutAngle, f32* reflectionIntensity) + { + Vector3d secondNormal; + if (normal.dot(rayDirection) < 0) + secondNormal = normal; + else + secondNormal = normal * -1; + + *reflectionDirection = rayDirection - normal * normal.dot(rayDirection) * 2.0f; + + bool isRayGoingToObject = (normal.dot(secondNormal) > 0.0f); + f32 refractiveIndex = isRayGoingToObject ? refractiveIndexIn / refractiveIndexOut + : refractiveIndexOut / refractiveIndexIn; + f32 cosInAngle = rayDirection.dot(secondNormal); + *cosOutAngle = 1.0f - refractiveIndex * refractiveIndex * (1.0f - cosInAngle * cosInAngle); + + if (*cosOutAngle >= 0) + { + *refractionDirection = rayDirection * refractiveIndex - + normal * ((isRayGoingToObject ? 1 : -1) * + (cosInAngle * refractiveIndex + sqrt(*cosOutAngle))); + refractionDirection->normalize(); + f32 reflectivity = pow((refractiveIndex - 1), 2) / pow((refractiveIndex + 1), 2); + f32 angle = (isRayGoingToObject ? -cosInAngle : refractionDirection->dot(normal)); + *reflectionIntensity = reflectivity + (1.0f - reflectivity) * pow((1.0f - angle), 5); + } + } +} // namespace PRRPM \ No newline at end of file diff --git a/src/stb_image_write.cpp b/src/stb_image_write.cpp new file mode 100644 index 0000000..527b61a --- /dev/null +++ b/src/stb_image_write.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include "./3rdparty/stb_collection/stb_image_write.h" \ No newline at end of file diff --git a/src/vector3d.h b/src/vector3d.h new file mode 100644 index 0000000..8e99929 --- /dev/null +++ b/src/vector3d.h @@ -0,0 +1,167 @@ + +/************************************************************ +Title : A Photo-realistic Renderer Based on Photon Mapping +Students : Davood Rasti + Alireza Rasti + +Version : 0.01 +Date : 23-06-2012 +Updated : 01-10-2026 +*************************************************************/ +#pragma once + +#include "common.h" +#include + +namespace PRRPM +{ + class Vector3d + { + public: + Vector3d() = default; + + constexpr Vector3d(PRRPM::f32 x, PRRPM::f32 y, PRRPM::f32 z) : x(x), y(y), z(z) + { + } + + inline Vector3d operator+(const Vector3d& secondVector) const + { + return Vector3d(x + secondVector.x, y + secondVector.y, z + secondVector.z); + } + + inline Vector3d operator-(const Vector3d& secondVector) const + { + return Vector3d(x - secondVector.x, y - secondVector.y, z - secondVector.z); + } + + inline Vector3d operator*(const Vector3d& secondVector) const + { + return Vector3d(x * secondVector.x, y * secondVector.y, z * secondVector.z); + } + + inline Vector3d operator/(const Vector3d& secondVector) const + { + return Vector3d(x / secondVector.x, y / secondVector.y, z / secondVector.z); + } + + inline Vector3d& operator+=(const Vector3d& secondVector) + { + x += secondVector.x; + y += secondVector.y; + z += secondVector.z; + return *this; + } + + inline Vector3d& operator-=(const Vector3d& secondVector) + { + x -= secondVector.x; + y -= secondVector.y; + z -= secondVector.z; + return *this; + } + + inline Vector3d& operator*=(const Vector3d& secondVector) + { + x *= secondVector.x; + y *= secondVector.y; + z *= secondVector.z; + return *this; + } + + inline Vector3d& operator/=(const Vector3d& secondVector) + { + x /= secondVector.x; + y /= secondVector.y; + z /= secondVector.z; + return *this; + } + + inline bool operator==(const Vector3d& secondVector) const + { + return (x == secondVector.x && y == secondVector.y && z == secondVector.z); + } + + inline bool operator!=(const Vector3d& secondVector) const + { + return !(*this == secondVector); + } + + inline Vector3d operator+(f32 value) const + { + return Vector3d(x + value, y + value, z + value); + } + + inline Vector3d operator-(f32 value) const + { + return Vector3d(x - value, y - value, z - value); + } + + inline Vector3d operator*(f32 value) const + { + return Vector3d(x * value, y * value, z * value); + } + + inline Vector3d operator/(f32 value) const + { + return Vector3d(x / value, y / value, z / value); + } + + inline PRRPM::f32 dot(const Vector3d& secondVector) const + { + return x * secondVector.x + y * secondVector.y + z * secondVector.z; + } + + inline PRRPM::f32 getLength() const + { + return std::sqrt(getLengthSquared()); + } + + inline PRRPM::f32 getLengthSquared() const + { + return x * x + y * y + z * z; + } + + inline PRRPM::f32 getLengthSquard() const + { + return getLengthSquared(); + } + + inline PRRPM::f32 getDistance(const Vector3d& secondVector) const + { + return (*this - secondVector).getLength(); + } + + inline PRRPM::f32 getDistanceSquared(const Vector3d& secondVector) const + { + return (*this - secondVector).getLengthSquared(); + } + + inline PRRPM::f32 getDistanceSquard(const Vector3d& secondVector) const + { + return getDistanceSquared(secondVector); + } + + inline Vector3d cross(const Vector3d& secondVector) const + { + return Vector3d(y * secondVector.z - z * secondVector.y, + z * secondVector.x - x * secondVector.z, + x * secondVector.y - y * secondVector.x); + } + + inline void normalize() + { + const PRRPM::f32 length = getLength(); + if (length > 0.0f) + { + x /= length; + y /= length; + z /= length; + } + } + + PRRPM::f32 x = 0.0f; + PRRPM::f32 y = 0.0f; + PRRPM::f32 z = 0.0f; + }; + +} // namespace PRRPM \ No newline at end of file