{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gif87a\n",
    "[gif 87a 用プログラム](http://fortran66.hatenablog.com/entry/2018/05/12/170408)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%fcflags:-fno-range-check\n",
    "    module m_gif_types\n",
    "        use, intrinsic :: iso_fortran_env\n",
    "        implicit none    \n",
    "        private\n",
    "        public :: t_gif_header, t_image_block, int8\n",
    "\n",
    "        interface t_gif_header\n",
    "            procedure :: init_gif_header\n",
    "        end interface \n",
    "        \n",
    "        interface t_image_block\n",
    "            procedure :: init_image_block\n",
    "        end interface \n",
    "        \n",
    "        type :: t_gif_header\n",
    "            sequence  \n",
    "            character(3)   :: signature               = 'GIF'\n",
    "            character(3)   :: version                 = '87a'\n",
    "            integer(int16) :: width     \n",
    "            integer(int16) :: height    \n",
    "            integer(int8)  :: pck                     = int(B'10001000', int8) \n",
    "                                                        !1:Global Col. 3:Color Res. 1:Sort Flg. 3:Size of Global Col.\n",
    "            integer(int8)  :: background_color_index  = 0\n",
    "            integer(int8)  :: pixel_aspect_ratio      = 0\n",
    "        end type  \n",
    "        \n",
    "        type :: t_image_block\n",
    "            sequence\n",
    "            integer(int8)  :: separator               = int(Z'2C', int8)\n",
    "            integer(int16) :: left_position           = 00\n",
    "            integer(int16) :: top_position            = 00\n",
    "            integer(int16) :: width  \n",
    "            integer(int16) :: height \n",
    "            integer(int8)  :: pck                     = int(B'00000000', int8)\n",
    "            ! local color table\n",
    "            !integer(int8) :: LZW_minimum_code_size \n",
    "            !integer(int8) :: block_size  \n",
    "            !integer(int8) :: image_data (:)\n",
    "            !integer(int8) :: block_terminator        = int(Z'00', int8)  \n",
    "        end type t_image_block\n",
    "    contains\n",
    "        pure type(t_gif_header) function init_gif_header(nx, ny, ngcol) result(res)\n",
    "            integer, intent(in) :: nx, ny, ngcol\n",
    "            res%width  = nx\n",
    "            res%height = ny\n",
    "            res%pck = iand(res%pck, int(B'11111000', int8)) + int(mod(ngcol, 8), int8) \n",
    "                      !least 3bits:size of global color:2**(ngcol + 1) 2..256\n",
    "        end function init_gif_header\n",
    "    \n",
    "        pure type(t_image_block) function init_image_block(nx, ny) result(res)\n",
    "            integer, intent(in) :: nx, ny\n",
    "            res%width  = nx\n",
    "            res%height = ny\n",
    "        end function init_image_block\n",
    "    end module m_gif_types \n",
    "\n",
    "    \n",
    "    module m_gif_lzw\n",
    "        use :: m_gif_types\n",
    "        implicit none\n",
    "        private\n",
    "        public :: encoder\n",
    "        type :: t_enc\n",
    "            integer :: kbits = 0, id = 0\n",
    "        end type    \n",
    "    contains\n",
    "        subroutine enc(irgb, nbits, code)               ! gif LZW \n",
    "            integer, intent(in) :: irgb(:), nbits\n",
    "            type (t_enc), intent(out) :: code(:)\n",
    "            integer :: dict(0:2**12 - 1) ! 0:4095\n",
    "            integer :: kbits, kd, m0                    ! <== m0 state variable\n",
    "            integer :: ip, ic, ienc\n",
    "            call clear_dict()                           ! clear dictionary \n",
    "            ic = 1\n",
    "            code(ic) = t_enc(kbits, 2**nbits)           ! clear_code \n",
    "            m0 = irgb(1)\n",
    "            do ip = 2, size(irgb)\n",
    "                call subenc(ienc, irgb(ip)) \n",
    "                if (ienc /= -1) then                    ! new word \n",
    "                     ic = ic + 1\n",
    "                     code(ic) = t_enc(kbits, ienc)\n",
    "                end if  \n",
    "                if (kd == 2**12 - 1) then               ! dictionary full\n",
    "                    ic = ic + 1  \n",
    "                    code(ic) = t_enc(kbits, 2**nbits)   ! clear_code\n",
    "                    call clear_dict()                   ! clear dictionary \n",
    "                end if\n",
    "            end do\n",
    "            ic = ic + 1\n",
    "            code(ic) = t_enc(kbits, m0)\n",
    "            ic = ic + 1 \n",
    "            code(ic) = t_enc(kbits, dict(2**nbits + 1)) ! end_code  \n",
    "        contains\n",
    "            subroutine subenc(ienc, m1)\n",
    "                integer, intent(out) :: ienc\n",
    "                integer, intent(in ) :: m1\n",
    "                integer :: k, id\n",
    "                k = ishft(m0 + 1, 16) + m1              ! m0 + 1 to avoid 00...0 degeneracy \n",
    "                id = findloc(dict, k, dim = 1)          ! dictionary is 0-based \n",
    "                if (id == 0) then                       ! not found in the dictionary\n",
    "                    kd = kd + 1\n",
    "                    dict(kd) = k\n",
    "                    if (kd == 2**kbits + 1) kbits = kbits + 1\n",
    "                    ienc = m0\n",
    "                    m0 = m1\n",
    "                else                                    ! found in the dictionary\n",
    "                    ienc = -1\n",
    "                    m0 = id - 1                         ! because dictionary is 0-based, m0 must be shifted by 1\n",
    "                end if    \n",
    "            end subroutine subenc\n",
    "\n",
    "            subroutine clear_dict()\n",
    "                integer :: i\n",
    "                kbits = nbits + 1\n",
    "                kd = 2**nbits + 1 ! dictinary defined\n",
    "                dict = 0\n",
    "                forall(i = 0:kd) dict(i) = i ! dict(nbit):clear code; dict(nbit+1):end code \n",
    "            end subroutine clear_dict\n",
    "        end subroutine enc\n",
    "      \n",
    "        subroutine encoder(irgb, nbits, icode)\n",
    "            integer, intent(in ) :: irgb(:), nbits\n",
    "            integer(int8), allocatable, intent(out) :: icode(:)\n",
    "            type(t_enc), allocatable :: code(:)\n",
    "            integer :: i, j, k, ib, ic, nb  \n",
    "            allocate(code(size(irgb) + 100))            ! ? large enough ?\n",
    "            call enc(irgb, nbits, code)                 ! compress color code to LZW code\n",
    "            nb = ceiling(sum(code(:)%kbits) / 8.0)      !   required bytes  \n",
    "            allocate(icode(nb))\n",
    "            icode = 0                                   ! pack LZW code to bit string    \n",
    "            k = 0\n",
    "            do i = 1, size(code)                          \n",
    "                do j = 1, code(i)%kbits   \n",
    "                    if (btest(code(i)%id, j - 1)) then \n",
    "                        ic = k / 8 + 1 \n",
    "                        ib = mod(k, 8)\n",
    "                        icode(ic) = ibset(icode(ic), ib)\n",
    "                    end if\n",
    "                    k = k + 1\n",
    "                end do  \n",
    "            end do            \n",
    "        end subroutine encoder \n",
    "    end module m_gif_lzw\n",
    "    \n",
    "    \n",
    "    module m_gif\n",
    "        use :: m_gif_types\n",
    "        use :: m_gif_lzw\n",
    "        implicit none\n",
    "        private\n",
    "        public :: wr_gif\n",
    "    contains\n",
    "        subroutine wr_gif(fn, irgb2, n_global_color, global_color_table) \n",
    "            character(*), intent(in) :: fn\n",
    "            integer, intent(in), contiguous, target :: irgb2(:, :)\n",
    "            integer, intent(in) :: n_global_color, global_color_table(:)\n",
    "            integer(int8), allocatable :: icode(:)\n",
    "            integer, pointer :: irgb(:)\n",
    "            type(t_gif_header ) :: head\n",
    "            type(t_image_block) :: img\n",
    "            integer :: nx, ny, iw, nbits\n",
    "            nx = size(irgb2, 1)\n",
    "            ny = size(irgb2, 2)\n",
    "            nbits = max(2, n_global_color + 1)           ! 1..8 -> 2,2,3,4,5,6,7,8\n",
    "            head = t_gif_header(nx, ny, n_global_color)\n",
    "            img  = t_image_block(nx, ny)\n",
    "            open(newunit = iw, file = fn, access = 'stream') \n",
    "            write(iw) head      \n",
    "            write(iw) int(global_color_table, int8)\n",
    "            write(iw) img    \n",
    "            irgb(1:size(irgb2)) => irgb2                 ! 1D => 2D \n",
    "            call encoder(irgb, nbits, icode)             ! color code to GIF LZW code         \n",
    "            block\n",
    "                integer :: i, nbyte\n",
    "                write(iw) int(nbits, int8)               ! LZW_minimum_code_size = 2,2,3,4,5,6,7,8   \n",
    "                do i = 1, size(icode), 255         \n",
    "                    nbyte = min(i + 255, size(icode)) - i\n",
    "                    write(iw) achar(nbyte)             \n",
    "                    write(iw) icode(i:i+nbyte-1)\n",
    "                end do  \n",
    "                write(iw) achar(00)                      ! block_terminator\n",
    "            end block\n",
    "            write(iw) achar(int(Z'3B'))                  ! end of gif file\n",
    "            close(iw)\n",
    "        end subroutine wr_gif  \n",
    "    end module m_gif\n",
    "    \n",
    "    \n",
    "    program mandel\n",
    "        implicit none\n",
    "        integer, parameter :: nx = 500, ny = 500, maxiter = 255\n",
    "        real   , parameter :: x0 = -2.0, x1 = 1.0, y0 = -1.5, y1 = 1.5\n",
    "        complex, allocatable :: c(:, :), z(:, :)                 \n",
    "        integer, allocatable :: niter(:, :)\n",
    "        integer :: ix, iy, iter\n",
    "        allocate(c(nx, ny), z(nx, ny), niter(nx, ny))    ! make 2D-mesh   \n",
    "! Mandelbrot set\n",
    "        forall(ix = 1:nx, iy = 1:ny) &\n",
    "              c(ix, iy) = cmplx(x0, y0) &\n",
    "                        + cmplx((x1 - x0) / (nx - 1) * (ix - 1), (y1 - y0) / (ny - 1) * (iy - 1))\n",
    "        niter = 0\n",
    "        do iter = 1, maxiter\n",
    "            where (abs(z) <= 2.0) \n",
    "                z = z**2 + c\n",
    "                niter = niter + 1\n",
    "            end where \n",
    "        end do\n",
    "!  \n",
    "        block                                            ! set global color table\n",
    "            integer :: i, n_global_color                    ! 0..7 ! 2..256 colors (2^(n_global_color + 1)) \n",
    "            integer, allocatable :: global_color_table(:)\n",
    "            n_global_color = 7\n",
    "            allocate(global_color_table(3 * 2**(n_global_color + 1)))\n",
    "            global_color_table = 0\n",
    "            forall(i = 0:254) global_color_table(3*i+1:3*i+3) = i   ! BW 256\n",
    "! write gif file\n",
    "            block\n",
    "                use :: m_gif\n",
    "                call wr_gif('mandel.gif', niter, n_global_color, global_color_table)\n",
    "            end block\n",
    "        end block\n",
    "    end program mandel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/gif": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%image:mandel.gif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "gfortran",
   "language": "Fortran",
   "name": "gfort_spec"
  },
  "language_info": {
   "file_extension": "f90",
   "mimetype": "text/plain",
   "name": "fortran"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}