image

#!/bin/bash

################################################################################
#      This file is part of OpenELEC - http://www.openelec.tv
#      Copyright (C) 2009-2016 Stephan Raue (stephan@openelec.tv)
#
#  OpenELEC is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 2 of the License, or
#  (at your option) any later version.
#
#  OpenELEC is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with OpenELEC.  If not, see <http://www.gnu.org/licenses/>.
################################################################################

. config/options $1

show_config

$SCRIPTS/checkdeps
$SCRIPTS/build toolchain
$SCRIPTS/build squashfs:host
$SCRIPTS/build dosfstools:host
$SCRIPTS/build fakeroot:host
$SCRIPTS/build kmod:host
$SCRIPTS/build mtools:host
$SCRIPTS/build populatefs:host

BUILD_DATE=`date +%Y%m%d%H%M%S`

GIT_HASH=$(git rev-parse HEAD)

if [ "$LIBREELEC_VERSION" = "devel" ]; then
  if ! GIT_BUILD=$(git rev-list --count HEAD 2>/dev/null)
  then
    GIT_BUILD=$(git rev-list HEAD | wc -l)
  fi
  GIT_ABBREV=$(git log -1 --pretty=format:%h)
  DEVEL_VERSION=$LIBREELEC_VERSION
  LIBREELEC_VERSION=$LIBREELEC_VERSION-$BUILD_DATE-r$GIT_BUILD-g$GIT_ABBREV
fi

# Get origin url, fix git:// and git@github.com: urls if necessary
ORIGIN_URL="$(git remote -v | awk '$1 == "origin" { print $2 }' | head -1 | sed 's#\.git$##;s#^git:#https:#;s#^git@github\.com:#https://github.com/#')"

if [ "$OFFICIAL" = "yes" ]; then
  LIBREELEC_BUILD="official"
else
  LIBREELEC_BUILD="community"
fi

if [ -z "$DEVICE" ]; then
  TARGET_VERSION="$PROJECT.$TARGET_ARCH-$LIBREELEC_VERSION"
else
  TARGET_VERSION="$PROJECT.$DEVICE.$TARGET_ARCH-$LIBREELEC_VERSION"
fi
IMAGE_NAME="$DISTRONAME-$TARGET_VERSION"

# Set Amlogic update package name
AML_UPDATE_NAME="$IMAGE_NAME"

if [ "$DEVEL_VERSION" = "devel" ] ; then
  if [ -z "$DEVICE" ]; then
    IMAGE_NAME="$DISTRONAME-$PROJECT.$TARGET_ARCH-$OS_VERSION-$LIBREELEC_VERSION"
    AML_UPDATE_NAME="$DISTRONAME-$PROJECT.$TARGET_ARCH-$OS_VERSION-$DEVEL_VERSION"
  else
    IMAGE_NAME="$DISTRONAME-$PROJECT.$DEVICE.$TARGET_ARCH-$OS_VERSION-$LIBREELEC_VERSION"
    AML_UPDATE_NAME="$DISTRONAME-$PROJECT.$DEVICE.$TARGET_ARCH-$OS_VERSION-$DEVEL_VERSION"
  fi
fi

if [ "$PROJECT" == "imx6" -a -n "$SYSTEM" ]; then
  IMAGE_NAME="$IMAGE_NAME-$SYSTEM"
fi

if [ -n "$CUSTOM_IMAGE_NAME" ]; then
   IMAGE_NAME="$CUSTOM_IMAGE_NAME"
fi

if [ -n "$IMAGE_SUFFIX" ]; then
  IMAGE_NAME="$IMAGE_NAME-$IMAGE_SUFFIX"
fi

# setup fakeroot
  rm -rf $FAKEROOT_SCRIPT   # remove $FAKEROOT_SCRIPT if it exist
  touch $FAKEROOT_SCRIPT    # create an empty $FAKEROOT_SCRIPT
  chmod +x $FAKEROOT_SCRIPT # make $FAKEROOT_SCRIPT executable
  echo "chown -R 0:0 $INSTALL" >> $FAKEROOT_SCRIPT

# clean old install dirs
  rm -rf $INSTALL
  rm -rf $STAMPS_INSTALL
  mkdir -p $INSTALL

# create baselayout
  mkdir -p $INSTALL/bin
  mkdir -p $INSTALL/etc
  mkdir -p $INSTALL/lib
  mkdir -p $INSTALL/sbin
  mkdir -p $INSTALL/dev
  mkdir -p $INSTALL/proc
  mkdir -p $INSTALL/run
  mkdir -p $INSTALL/sys
  mkdir -p $INSTALL/tmp
  mkdir -p $INSTALL/usr
  mkdir -p $INSTALL/var
  mkdir -p $INSTALL/flash
  mkdir -p $INSTALL/storage
  ln -sf /var/media $INSTALL/media

  if [ "$TARGET_ARCH" = "x86_64" -o "$TARGET_ARCH" = "powerpc64" ]; then
    ln -s /lib $INSTALL/lib64
    ln -s lib $INSTALL/usr/lib64
  fi

  echo "$TARGET_VERSION" > $INSTALL/etc/release

# create /etc/os-release
  echo -e "NAME=\"$DISTRONAME\"" > $INSTALL/etc/os-release
  echo -e "VERSION=\"$LIBREELEC_VERSION\"" >> $INSTALL/etc/os-release
  echo -e "ID=\"libreelec\"" >> $INSTALL/etc/os-release
  echo -e "VERSION_ID=\"$OS_VERSION\"" >> $INSTALL/etc/os-release
  echo -e "PRETTY_NAME=\"$DISTRONAME ($LIBREELEC_BUILD) - Version: $LIBREELEC_VERSION\"" >> $INSTALL/etc/os-release
  echo -e "HOME_URL=\"http://www.libreelec.tv\"" >> $INSTALL/etc/os-release
  echo -e "BUG_REPORT_URL=\"$ORIGIN_URL\"" >> $INSTALL/etc/os-release
  echo -e "BUILD_ID=\"$GIT_HASH\"" >> $INSTALL/etc/os-release
  echo -e "OPENELEC_ARCH=\"$PROJECT.$TARGET_ARCH\"" >> $INSTALL/etc/os-release
  echo -e "LIBREELEC_ARCH=\"$PROJECT.$TARGET_ARCH\"" >> $INSTALL/etc/os-release
  echo -e "LIBREELEC_BUILD=\"$LIBREELEC_BUILD\"" >> $INSTALL/etc/os-release

# create /etc/issue
  echo "$GREETING0" >  $INSTALL/etc/issue
  echo "$GREETING1" >> $INSTALL/etc/issue
  echo "$GREETING2" >> $INSTALL/etc/issue
  echo "$GREETING3" >> $INSTALL/etc/issue
  echo "$GREETING4" >> $INSTALL/etc/issue
  echo "$DISTRONAME ($LIBREELEC_BUILD) Version: $LIBREELEC_VERSION" >> $INSTALL/etc/issue
  if [ "$DEVEL_VERSION" = "devel" ] ; then
    echo "$DISTRONAME git: $GIT_HASH" >> $INSTALL/etc/issue
  fi

  ln -sf /etc/issue $INSTALL/etc/motd

# Basissystem...
  $SCRIPTS/install libc
  $SCRIPTS/install gcc
  $SCRIPTS/install linux
  $SCRIPTS/install linux-drivers
  $SCRIPTS/install linux-firmware
  $SCRIPTS/install $BOOTLOADER
  $SCRIPTS/install busybox
  $SCRIPTS/install util-linux
  $SCRIPTS/install corefonts
  $SCRIPTS/install network

# Graphic support
  [ ! "$DISPLAYSERVER" = "no" ] && $SCRIPTS/install $DISPLAYSERVER

# Multimedia support
  [ ! "$MEDIACENTER" = "no" ] && $SCRIPTS/install mediacenter

# Sound support
  [ "$ALSA_SUPPORT" = "yes" ] && $SCRIPTS/install alsa

# Automounter support
  [ "$UDEVIL" = "yes" ] && $SCRIPTS/install udevil

# NTFS 3G support
  [ "$EXFAT" = "yes" ] && $SCRIPTS/install fuse-exfat

# NTFS 3G support
  [ "$NTFS3G" = "yes" ] && $SCRIPTS/install ntfs-3g_ntfsprogs

# Remote support
  [ "$REMOTE_SUPPORT" = "yes" ] && $SCRIPTS/install remote

# LCD support
  [ ! "$LCD_DRIVER" = "none" ] && $SCRIPTS/install lcdproc

# Installer support
  [ "$INSTALLER_SUPPORT" = "yes" ] && $SCRIPTS/install installer

# Devtools... (not for Release)
  [ "$TESTING" = "yes" ] && $SCRIPTS/install testing

# Install gdb in all builds, including releases
  $SCRIPTS/install debug

# OEM packages
  [ "$OEM_SUPPORT" = "yes" ] && $SCRIPTS/install oem

# copy project related files to filesystem
  if [ -d "$PROJECT_DIR/$PROJECT/filesystem" ]; then
    cp -PR $PROJECT_DIR/$PROJECT/filesystem/* $INSTALL
    # install project specific systemd services
    for service in $PROJECT_DIR/$PROJECT/filesystem/usr/lib/systemd/system/*.service ; do
      if [ -f "$service" ] ; then
        enable_service $(basename $service)
      fi
    done
  fi

# copy vendor related files to filesystem
  if [ -d "$HOME/.libreelec/filesystem" ]; then
    cp -PR $HOME/.libreelec/filesystem/* $INSTALL
    # install project specific systemd services
    for service in $HOME/.libreelec/filesystem/usr/lib/systemd/system/*.service ; do
      if [ -f "$service" ] ; then
        enable_service $(basename $service)
      fi
    done
  fi

# copy vendor project related files to filesystem
  if [ -d "$HOME/.libreelec/projects/$PROJECT/filesystem" ]; then
    cp -PR $HOME/.libreelec/projects/$PROJECT/filesystem/* $INSTALL
    # install project specific systemd services
    for service in $HOME/.libreelec/projects/$PROJECT/filesystem/usr/lib/systemd/system/*.service ; do
      if [ -f "$service" ] ; then
        enable_service $(basename $service)
      fi
    done
  fi

# copy board related files to filesystem
  if [ -n "$DEVICE" -a -d "$PROJECT_DIR/$PROJECT/devices/$DEVICE/filesystem" ]; then
    cp -PR $PROJECT_DIR/$PROJECT/devices/$DEVICE/filesystem/* $INSTALL
    # install device specific systemd services
    for service in $PROJECT_DIR/$PROJECT/devices/$DEVICE/filesystem/usr/lib/systemd/system/*.service ; do
      if [ -f "$service" ] ; then
        enable_service $(basename $service)
      fi
    done
  fi

# run depmod
  MODVER=$(basename $(ls -d $INSTALL/lib/modules/*))
  find $INSTALL/lib/modules/$MODVER/ -name *.ko | \
    sed -e "s,$INSTALL/lib/modules/$MODVER/,," > $INSTALL/lib/modules/$MODVER/modules.order
  $ROOT/$TOOLCHAIN/bin/depmod -b $INSTALL $MODVER 2> /dev/null

# strip kernel modules
  for MOD in `find $INSTALL/lib/modules/ -type f -name *.ko`; do
    $STRIP --strip-debug $MOD
  done

# make target dir
  mkdir -p $TARGET_IMG
    rm -rf $TARGET_IMG/$IMAGE_NAME.kernel

# copy kernel to target dir
  if [ "$BOOTLOADER" = "bcm2835-bootloader" ]; then
    echo "injecting DeviceTreeBlobs to kernel..."
    perl $BUILD/linux-$(kernel_version)/scripts/mkknlimg $BUILD/linux-$(kernel_version)/arch/$TARGET_KERNEL_ARCH/boot/$KERNEL_TARGET $TARGET_IMG/$IMAGE_NAME.kernel
    echo "...done"
  elif [ "$BUILD_ANDROID_BOOTIMG" = "yes" ]; then
    echo "Building Amlogic DeviceTreeBlobs and injecting them to kernel..."
    pushd "$BUILD/linux-$(kernel_version)" > /dev/null
    rm -rf arch/$TARGET_KERNEL_ARCH/boot/dts/amlogic/*.dtb arch/$TARGET_KERNEL_ARCH/boot/dtb.img arch/$TARGET_KERNEL_ARCH/boot/boot.img
    for extra_target in $KERNEL_UBOOT_EXTRA_TARGET; do
      LDFLAGS="" make $extra_target > /dev/null
    done
    DTB_BLOBS=($(ls arch/$TARGET_KERNEL_ARCH/boot/dts/amlogic/*.dtb 2>/dev/null || true))
    DTB_BLOBS_COUNT="${#DTB_BLOBS[@]}"
    DTB_BLOB_OUTPUT="arch/$TARGET_KERNEL_ARCH/boot/dtb.img"
    MKBOOTIMG_SECOND="--second $DTB_BLOB_OUTPUT"
    if [ "$DTB_BLOBS_COUNT" -gt 1 ]; then
      $ROOT/tools/dtbTool/dtbTool -o $DTB_BLOB_OUTPUT -p scripts/dtc/ arch/$TARGET_KERNEL_ARCH/boot/dts/amlogic/
    elif [ "$DTB_BLOBS_COUNT" -eq 1 ]; then
      cp -f arch/$TARGET_KERNEL_ARCH/boot/dts/amlogic/*.dtb $DTB_BLOB_OUTPUT
    else
      MKBOOTIMG_SECOND=""
    fi
    mkbootimg --kernel arch/$TARGET_KERNEL_ARCH/boot/$KERNEL_TARGET --ramdisk $ROOT/$BUILD/image/initramfs.cpio \
      $MKBOOTIMG_SECOND $MKBOOTIMG_OPTIONS --output arch/$TARGET_KERNEL_ARCH/boot/boot.img
    echo "...done"
    if [ -f $DTB_BLOB_OUTPUT ]; then
      cp -f $DTB_BLOB_OUTPUT $TARGET_IMG/$IMAGE_NAME.dtb
    fi
    popd > /dev/null

    cp -PR $BUILD/linux-$(kernel_version)/arch/$TARGET_KERNEL_ARCH/boot/boot.img $TARGET_IMG/$IMAGE_NAME.kernel
  else
    cp -PR $BUILD/linux-$(kernel_version)/arch/$TARGET_KERNEL_ARCH/boot/$KERNEL_TARGET $TARGET_IMG/$IMAGE_NAME.kernel
  fi
  chmod 0644 $TARGET_IMG/$IMAGE_NAME.kernel

# create squashfs file
  if [ -z "$SQUASHFS_COMPRESSION" ]; then
    SQUASHFS_COMPRESSION="gzip"
  fi

  if [ "$SQUASHFS_COMPRESSION" = "lz4" ]; then
    SQUASHFS_COMPRESSION_LEVEL="-Xhc"
  fi

  if [ -z "$SQUASHFS_BLOCK_SIZE" ]; then
    SQUASHFS_BLOCK_SIZE="131072"
  fi

  echo "rm -rf $TARGET_IMG/$IMAGE_NAME.system" >> $FAKEROOT_SCRIPT
  echo "$ROOT/$TOOLCHAIN/bin/mksquashfs $BUILD/image/system $TARGET_IMG/$IMAGE_NAME.system -noappend -b $SQUASHFS_BLOCK_SIZE -comp $SQUASHFS_COMPRESSION $SQUASHFS_COMPRESSION_LEVEL" >> $FAKEROOT_SCRIPT

# run fakeroot
  $ROOT/$TOOLCHAIN/bin/fakeroot -- $FAKEROOT_SCRIPT
  rm -rf $FAKEROOT_SCRIPT

# set permissions
  chmod 0644 $TARGET_IMG/$IMAGE_NAME.system

  if [ "$1" = "release" -o "$1" = "mkimage" -o "$1" = "amlpkg" -o "$1" = "noobs" ]; then

    RELEASE_DIR="target/$IMAGE_NAME"

    if [ -n "$DEVICE" -a -d "$PROJECT_DIR/$PROJECT/devices/$DEVICE/install" ]; then
      INSTALL_SRC_DIR="$PROJECT_DIR/$PROJECT/devices/$DEVICE/install"
    else
      INSTALL_SRC_DIR="$PROJECT_DIR/$PROJECT/install"
    fi

    MKIMAGE_TOOL_CMD="$(which mkimage) -A $TARGET_KERNEL_ARCH -O linux -T script -C none -d"

    # cleanup
      rm -rf $RELEASE_DIR

    # create release dir
      mkdir -p $RELEASE_DIR
      # remove n previous created release image
        rm -rf $TARGET_IMG/$IMAGE_NAME.img.gz
        if [ -n "$BOOTLOADER" ]; then

          BOOTLOADER_DIR=""

          if [ -z "$BOOTLOADER_DIR" -a -d $HOME/.openelec/projects/$PROJECT/packages ]; then
            BOOTLOADER_DIR=`find $HOME/.openelec/projects/$PROJECT/packages -type d -name $BOOTLOADER 2>/dev/null`
          fi

          if [ -z "$BOOTLOADER_DIR" -a -d $HOME/.openelec/packages ]; then
            BOOTLOADER_DIR=`find $HOME/.openelec/packages -type d -name $BOOTLOADER 2>/dev/null`
          fi

          if [ -z "$BOOTLOADER_DIR" -a -d $PROJECT_DIR/$PROJECT/packages ]; then
            BOOTLOADER_DIR=`find $PROJECT_DIR/$PROJECT/packages -type d -name $BOOTLOADER 2>/dev/null`
          fi

          if [ -z "$BOOTLOADER_DIR" -o ! -d "$BOOTLOADER_DIR" ]; then
            BOOTLOADER_DIR=`find $PACKAGES -type d -name $BOOTLOADER 2>/dev/null`
          fi

          if [ -d "$BOOTLOADER_DIR"/files ]; then
            cp -R $BOOTLOADER_DIR/files/* $RELEASE_DIR
          fi

          if [ -f $HOME/.openelec/projects/$PROJECT/bootloader/release ]; then
            . $HOME/.openelec/projects/$PROJECT/bootloader/release
          elif [ -f $HOME/.openelec/bootloader/release ]; then
            . $HOME/.openelec/bootloader/release
          elif [ -f $PROJECT_DIR/$PROJECT/bootloader/release ]; then
            . $PROJECT_DIR/$PROJECT/bootloader/release
          elif [ -f "$BOOTLOADER_DIR"/release ]; then
            . $BOOTLOADER_DIR/release
          fi
        fi

      # MfgTool2 for TBS Matrix support (add it to .tar)
      # only for matrix system or all? (one tar for all updates?)
        if [ "$PROJECT" == "imx6" -a "$SYSTEM" == "matrix" ]; then
          $SCRIPTS/unpack imx6-mfgtool2-tbs-matrix

          mkdir -p $RELEASE_DIR/MfgTool2-TBS-Matrix
          cp -PR $BUILD/imx6-mfgtool2-tbs-matrix-*/* $RELEASE_DIR/MfgTool2-TBS-Matrix
        fi

        cp $ROOT/README* $RELEASE_DIR
        cp $ROOT/CHANGELOG* $RELEASE_DIR
        echo "$TARGET_VERSION" > $RELEASE_DIR/RELEASE

        if [ -n "$MEDIACENTER" ] ; then
          echo "Kodi commit: `scripts/git_version $MEDIACENTER`" >> $RELEASE_DIR/RELEASE
        fi

      mkdir -p $RELEASE_DIR/licenses
        cp $ROOT/licenses/* $RELEASE_DIR/licenses

      mkdir -p $RELEASE_DIR/target
        cp $TARGET_IMG/$IMAGE_NAME.system $RELEASE_DIR/target/SYSTEM
        cp $TARGET_IMG/$IMAGE_NAME.kernel $RELEASE_DIR/target/KERNEL
    # create md5sum's
      ( cd $RELEASE_DIR;
        md5sum -t target/SYSTEM > target/SYSTEM.md5;
        md5sum -t target/KERNEL > target/KERNEL.md5;
      )

    # create target directory
      mkdir -p $TARGET_IMG

    # remove an previous created release tarball
      rm -rf $TARGET_IMG/$IMAGE_NAME.tar

    # create release tarball
      tar cf $TARGET_IMG/$IMAGE_NAME.tar -C target $IMAGE_NAME

    # create image files if requested
      if [[ ( "$1" = "amlpkg" || "$1" = "noobs" || "$1" = "mkimage" ) && -n "$BOOTLOADER" ]]; then
        # projects can set KERNEL_NAME (kernel.img)
        if [ -z "$KERNEL_NAME" ] ; then
          KERNEL_NAME="KERNEL"
        fi

        UBOOT_SYSTEM=""
        if [ "$PROJECT" == "imx6" ]; then
          if [ -n "$SYSTEM" ]; then
            UBOOT_SYSTEM="$SYSTEM"
          else
            UBOOT_SYSTEM="cuboxi"
          fi
        fi

        # variables used in image script must be passed
        env \
          PATH="$PATH:/sbin" \
          ROOT="$ROOT" \
          TOOLCHAIN="$TOOLCHAIN" \
          TARGET_IMG="$TARGET_IMG" \
          IMAGE_NAME="$IMAGE_NAME" \
          INSTALL_SRC_DIR="$INSTALL_SRC_DIR" \
          BOOTLOADER="$BOOTLOADER" \
          KERNEL_NAME="$KERNEL_NAME" \
          MKIMAGE_TOOL_CMD="$MKIMAGE_TOOL_CMD" \
          RELEASE_DIR="$RELEASE_DIR" \
          UUID_SYSTEM="$(uuidgen)" \
          UUID_STORAGE="$(uuidgen)" \
          UBOOT_SYSTEM="$UBOOT_SYSTEM" \
          EXTRA_CMDLINE="$EXTRA_CMDLINE" \
          SYSTEM_SIZE="$SYSTEM_SIZE" \
          SYSTEM_PART_START="$SYSTEM_PART_START" \
          $SCRIPTS/mkimage
      fi

      # cleanup release dir
      rm -rf $RELEASE_DIR

    # create WeTek Play (Amlogic) ZIP update and auto-install packages if requested
      if [ "$1" = "amlpkg" ]; then
        echo "Creating Amlogic ZIP update package"

        AML_PKG_DIR="$RELEASE_DIR/ampl-pkg"

        # create package directory
        mkdir -p "$AML_PKG_DIR"

        # copy system and kernel images
        mkdir -p "$AML_PKG_DIR/system"
        cp $TARGET_IMG/$IMAGE_NAME.system $AML_PKG_DIR/system/SYSTEM
        cp $TARGET_IMG/$IMAGE_NAME.kernel $AML_PKG_DIR/KERNEL

        # copy update-binary and updater-script
        META_INF_DIR="$AML_PKG_DIR/META-INF/com/google/android"
        mkdir -p "$META_INF_DIR"
        cp $INSTALL_SRC_DIR/update-binary $META_INF_DIR
        cp $INSTALL_SRC_DIR/updater-script $META_INF_DIR

        # copy device tree image if any
        if [ -f $TARGET_IMG/$IMAGE_NAME.dtb ]; then
          cp -f $TARGET_IMG/$IMAGE_NAME.dtb $AML_PKG_DIR/dtb.img
        fi

        # copy other files if any
        if [ -d "$INSTALL_SRC_DIR/files" ]; then
          cp -PR $INSTALL_SRC_DIR/files/* $AML_PKG_DIR
        fi

        # create the update package
        pushd "$AML_PKG_DIR" > /dev/null
        zip -rq update.zip *

        # sign the update package
        echo "Signing the update package"
        mkdir -p sign
        SIGNAPK_DIR="$ROOT/tools/signapk"
        java -Xmx1024m -jar $SIGNAPK_DIR/signapk.jar -w $SIGNAPK_DIR/testkey.x509.pem $SIGNAPK_DIR/testkey.pk8 update.zip sign/$AML_UPDATE_NAME-update.zip

        # create the auto-install package
        echo "Creating Amlogic ZIP auto-install package"
        pushd sign > /dev/null
        echo --update_package=/sdcard/$AML_UPDATE_NAME-update.zip > factory_update_param.aml
        if [ -f "$INSTALL_SRC_DIR/files/recovery.img" ]; then
          cp $INSTALL_SRC_DIR/files/recovery.img .
        fi
        if [ -f $INSTALL_SRC_DIR/files/aml_autoscript ]; then
          cp $INSTALL_SRC_DIR/files/aml_autoscript .
        elif [ -f "$INSTALL_SRC_DIR/aml_autoscript.src" ]; then
          $MKIMAGE_TOOL_CMD "$INSTALL_SRC_DIR/aml_autoscript.src" aml_autoscript > /dev/null
        fi
        zip -q $TARGET_IMG/$IMAGE_NAME.zip *
        popd > /dev/null

        popd > /dev/null

        # cleanup release dir
        rm -rf $RELEASE_DIR

      elif [ "$1" = "noobs" ]; then

        RELEASE_DIR="$TARGET_IMG/${IMAGE_NAME}-$1"

        # cleanup
          rm -rf $RELEASE_DIR

        # create release dir
          mkdir -p $RELEASE_DIR/${DISTRONAME}_${PROJECT}

          if [ -f $DISTRO_DIR/$DISTRO/${DISTRONAME}_40x40.png ]; then
            cp -PR $DISTRO_DIR/$DISTRO/${DISTRONAME}_40x40.png $RELEASE_DIR/${DISTRONAME}_${PROJECT}/${DISTRONAME}_${PROJECT}.png
          else
            cp -PR $DISTRO_DIR/$DISTRO/${DISTRONAME}.png $RELEASE_DIR/${DISTRONAME}_${PROJECT}/${DISTRONAME}_${PROJECT}.png
          fi
          cp -PR $ROOT/config/noobs/os.json $RELEASE_DIR/${DISTRONAME}_${PROJECT}
          cp -PR $ROOT/config/noobs/partition_setup.sh $RELEASE_DIR/${DISTRONAME}_${PROJECT}
          cp -PR $ROOT/config/noobs/partitions.json $RELEASE_DIR/${DISTRONAME}_${PROJECT}
          if [ -d $DISTRO_DIR/$DISTRO/noobs/marketing ]; then
            tar cf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/marketing.tar -C $DISTRO_DIR/$DISTRO/noobs/marketing .
          else
            tar cf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/marketing.tar -C $ROOT/config/noobs/marketing .
          fi
          cp $ROOT/README* $RELEASE_DIR/${DISTRONAME}_${PROJECT}
          cp $ROOT/CHANGELOG $RELEASE_DIR/${DISTRONAME}_${PROJECT}/release_notes.txt


          sed -e "s%@DISTRONAME@%$DISTRONAME%g" \
              -e "s%@PROJECT@%$PROJECT%g" \
              -e "s%@LIBREELEC_VERSION@%$LIBREELEC_VERSION%g" \
              -e "s%@RELEASE_DATE@%$(date +%F)%g" \
              -e "s%@KERNEL_VERSION@%$(kernel_version)%g" \
              -e "s%@DESCRIPTION@%$DESCRIPTION%g" \
              -e "s%@ROOT_PASSWORD@%$ROOT_PASSWORD%g" \
              -e "s%@NOOBS_SUPPORTED_MODELS@%$NOOBS_SUPPORTED_MODELS%g" \
              -e "s%@NOOBS_HEX@%$NOOBS_HEX%g" \
              -i $RELEASE_DIR/${DISTRONAME}_${PROJECT}/os.json

          sed -e "s%@DISTRONAME@%$DISTRONAME%g" \
              -e "s%@PROJECT@%$PROJECT%g" \
              -e "s%@SYSTEM_SIZE@%$SYSTEM_SIZE%g" \
              -i $RELEASE_DIR/${DISTRONAME}_${PROJECT}/partitions.json

        # create System dir
          mkdir -p $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System

            BOOTLOADER_DIR=`find $PACKAGES -type d -name $BOOTLOADER 2>/dev/null`
            if [ -d "$BOOTLOADER_DIR"/files/3rdparty/bootloader/ ]; then
              cp -PR $BOOTLOADER_DIR/files/3rdparty/bootloader/* $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System
            fi

          # copy Bootloader
            cp -PR $BUILD/bcm2835-bootloader-*/LICENCE* $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/
            cp -PR $BUILD/bcm2835-bootloader-*/bootcode.bin $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/
            cp -PR $BUILD/bcm2835-bootloader-*/fixup_x.dat $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/fixup.dat
            cp -PR $BUILD/bcm2835-bootloader-*/start_x.elf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/start.elf
            [ -f $BUILD/bcm2835-bootloader-*/dt-blob.bin ] && cp -PR $BUILD/bcm2835-bootloader-*/dt-blob.bin $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/dt-blob.bin

          # copy system files
            cp $TARGET_IMG/$IMAGE_NAME.system $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/SYSTEM
            cp $TARGET_IMG/$IMAGE_NAME.kernel $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/kernel.img

            for dtb in $INSTALL/usr/share/bootloader/*.dtb ; do
              if [ -f $dtb ]; then
                cp -PR $dtb $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System
              fi
            done

            for overlay in $INSTALL/usr/share/bootloader/overlays/* ; do
              if [ -f $overlay ]; then
                mkdir -p $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/overlays
                cp -PR $overlay $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/overlays
              fi
            done

          # create md5sum's
            ( cd $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System;
              md5sum -t SYSTEM > SYSTEM.md5;
              md5sum -t kernel.img > kernel.img.md5;
            )

          # copy additional files
            mkdir -p $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/licenses
              cp $ROOT/licenses/* $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/licenses

        # create Storage dir
          mkdir -p $RELEASE_DIR/${DISTRONAME}_${PROJECT}/Storage

        # remove an previous created release tarball
          rm -rf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/${DISTRONAME}_${PROJECT}_System.tar.xz
          rm -rf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/${DISTRONAME}_${PROJECT}_Storage.tar.xz

        # create filesystem tarballs
          tar cJf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/${DISTRONAME}_${PROJECT}_System.tar.xz -C $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System/ .
          tar cJf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/${DISTRONAME}_${PROJECT}_Storage.tar.xz -C $RELEASE_DIR/${DISTRONAME}_${PROJECT}/Storage/ .

        # remove an filesystem dirs
          rm -rf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/System
          rm -rf $RELEASE_DIR/${DISTRONAME}_${PROJECT}/Storage

        # remove an previous created release tarball
          rm -rf $TARGET_IMG/${IMAGE_NAME}-$1.tar

        # create release tarball
          tar cf $TARGET_IMG/${IMAGE_NAME}-$1.tar -C $TARGET ${IMAGE_NAME}-$1

        # cleanup noobs dir
          rm -rf $RELEASE_DIR
      fi
  fi