content: /*
   * Copyright 2002-2019 Drew Noakes and contributors
   *
   *    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
   *
   *        https://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.
   *
   * More information about this project is available at:
   *
   *    https://drewnoakes.com/code/exif/
   *    https://github.com/drewnoakes/metadata-extractor
   */
  package com.drew.metadata.jpeg;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  
  import com.drew.lang.annotations.NotNull;
  import com.drew.metadata.Directory;
  import com.drew.metadata.MetadataException;
  
  /**
   * Directory of tables for the DHT (Define Huffman Table(s)) segment.
   *
   * @author Nadahar
   */
  @SuppressWarnings("WeakerAccess")
  public class HuffmanTablesDirectory extends Directory
  {
      public static final int TAG_NUMBER_OF_TABLES = 1;
  
      static final byte[] TYPICAL_LUMINANCE_DC_LENGTHS = {
          (byte) 0x00, (byte) 0x01, (byte) 0x05, (byte) 0x01, (byte) 0x01, (byte) 0x01, (byte) 0x01, (byte) 0x01,
          (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00
      };
  
      static final byte[] TYPICAL_LUMINANCE_DC_VALUES = {
          (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06, (byte) 0x07,
          (byte) 0x08, (byte) 0x09, (byte) 0x0A, (byte) 0x0B
      };
  
      static final byte[] TYPICAL_CHROMINANCE_DC_LENGTHS = {
          (byte) 0x00, (byte) 0x03, (byte) 0x01, (byte) 0x01, (byte) 0x01, (byte) 0x01, (byte) 0x01, (byte) 0x01,
          (byte) 0x01, (byte) 0x01, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00
      };
  
      static final byte[] TYPICAL_CHROMINANCE_DC_VALUES = {
          (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06, (byte) 0x07,
          (byte) 0x08, (byte) 0x09, (byte) 0x0A, (byte) 0x0B
      };
  
      static final byte[] TYPICAL_LUMINANCE_AC_LENGTHS = {
          (byte) 0x00, (byte) 0x02, (byte) 0x01, (byte) 0x03, (byte) 0x03, (byte) 0x02, (byte) 0x04, (byte) 0x03,
          (byte) 0x05, (byte) 0x05, (byte) 0x04, (byte) 0x04, (byte) 0x00, (byte) 0x00, (byte) 0x01, (byte) 0x7D
      };
  
      static final byte[] TYPICAL_LUMINANCE_AC_VALUES = {
          (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x00, (byte) 0x04, (byte) 0x11, (byte) 0x05, (byte) 0x12,
          (byte) 0x21, (byte) 0x31, (byte) 0x41, (byte) 0x06, (byte) 0x13, (byte) 0x51, (byte) 0x61, (byte) 0x07,
          (byte) 0x22, (byte) 0x71, (byte) 0x14, (byte) 0x32, (byte) 0x81, (byte) 0x91, (byte) 0xA1, (byte) 0x08,
          (byte) 0x23, (byte) 0x42, (byte) 0xB1, (byte) 0xC1, (byte) 0x15, (byte) 0x52, (byte) 0xD1, (byte) 0xF0,
          (byte) 0x24, (byte) 0x33, (byte) 0x62, (byte) 0x72, (byte) 0x82, (byte) 0x09, (byte) 0x0A, (byte) 0x16,
          (byte) 0x17, (byte) 0x18, (byte) 0x19, (byte) 0x1A, (byte) 0x25, (byte) 0x26, (byte) 0x27, (byte) 0x28,
          (byte) 0x29, (byte) 0x2A, (byte) 0x34, (byte) 0x35, (byte) 0x36, (byte) 0x37, (byte) 0x38, (byte) 0x39,
          (byte) 0x3A, (byte) 0x43, (byte) 0x44, (byte) 0x45, (byte) 0x46, (byte) 0x47, (byte) 0x48, (byte) 0x49,
          (byte) 0x4A, (byte) 0x53, (byte) 0x54, (byte) 0x55, (byte) 0x56, (byte) 0x57, (byte) 0x58, (byte) 0x59,
          (byte) 0x5A, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, (byte) 0x68, (byte) 0x69,
          (byte) 0x6A, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, (byte) 0x78, (byte) 0x79,
          (byte) 0x7A, (byte) 0x83, (byte) 0x84, (byte) 0x85, (byte) 0x86, (byte) 0x87, (byte) 0x88, (byte) 0x89,
          (byte) 0x8A, (byte) 0x92, (byte) 0x93, (byte) 0x94, (byte) 0x95, (byte) 0x96, (byte) 0x97, (byte) 0x98,
          (byte) 0x99, (byte) 0x9A, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5, (byte) 0xA6, (byte) 0xA7,
          (byte) 0xA8, (byte) 0xA9, (byte) 0xAA, (byte) 0xB2, (byte) 0xB3, (byte) 0xB4, (byte) 0xB5, (byte) 0xB6,
          (byte) 0xB7, (byte) 0xB8, (byte) 0xB9, (byte) 0xBA, (byte) 0xC2, (byte) 0xC3, (byte) 0xC4, (byte) 0xC5,
          (byte) 0xC6, (byte) 0xC7, (byte) 0xC8, (byte) 0xC9, (byte) 0xCA, (byte) 0xD2, (byte) 0xD3, (byte) 0xD4,
          (byte) 0xD5, (byte) 0xD6, (byte) 0xD7, (byte) 0xD8, (byte) 0xD9, (byte) 0xDA, (byte) 0xE1, (byte) 0xE2,
          (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, (byte) 0xE8, (byte) 0xE9, (byte) 0xEA,
          (byte) 0xF1, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, (byte) 0xF8,
          (byte) 0xF9, (byte) 0xFA
      };
  
      static final byte[] TYPICAL_CHROMINANCE_AC_LENGTHS = {
          (byte) 0x00, (byte) 0x02, (byte) 0x01, (byte) 0x02, (byte) 0x04, (byte) 0x04, (byte) 0x03, (byte) 0x04,
          (byte) 0x07, (byte) 0x05, (byte) 0x04, (byte) 0x04, (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x77
      };
  
      static final byte[] TYPICAL_CHROMINANCE_AC_VALUES = {
          (byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x11, (byte) 0x04, (byte) 0x05, (byte) 0x21,
          (byte) 0x31, (byte) 0x06, (byte) 0x12, (byte) 0x41, (byte) 0x51, (byte) 0x07, (byte) 0x61, (byte) 0x71,
          (byte) 0x13, (byte) 0x22, (byte) 0x32, (byte) 0x81, (byte) 0x08, (byte) 0x14, (byte) 0x42, (byte) 0x91,
          (byte) 0xA1, (byte) 0xB1, (byte) 0xC1, (byte) 0x09, (byte) 0x23, (byte) 0x33, (byte) 0x52, (byte) 0xF0,
          (byte) 0x15, (byte) 0x62, (byte) 0x72, (byte) 0xD1, (byte) 0x0A, (byte) 0x16, (byte) 0x24, (byte) 0x34,
          (byte) 0xE1, (byte) 0x25, (byte) 0xF1, (byte) 0x17, (byte) 0x18, (byte) 0x19, (byte) 0x1A, (byte) 0x26,
          (byte) 0x27, (byte) 0x28, (byte) 0x29, (byte) 0x2A, (byte) 0x35, (byte) 0x36, (byte) 0x37, (byte) 0x38,
          (byte) 0x39, (byte) 0x3A, (byte) 0x43, (byte) 0x44, (byte) 0x45, (byte) 0x46, (byte) 0x47, (byte) 0x48,
          (byte) 0x49, (byte) 0x4A, (byte) 0x53, (byte) 0x54, (byte) 0x55, (byte) 0x56, (byte) 0x57, (byte) 0x58,
          (byte) 0x59, (byte) 0x5A, (byte) 0x63, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x67, (byte) 0x68,
          (byte) 0x69, (byte) 0x6A, (byte) 0x73, (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, (byte) 0x78,
          (byte) 0x79, (byte) 0x7A, (byte) 0x82, (byte) 0x83, (byte) 0x84, (byte) 0x85, (byte) 0x86, (byte) 0x87,
          (byte) 0x88, (byte) 0x89, (byte) 0x8A, (byte) 0x92, (byte) 0x93, (byte) 0x94, (byte) 0x95, (byte) 0x96,
          (byte) 0x97, (byte) 0x98, (byte) 0x99, (byte) 0x9A, (byte) 0xA2, (byte) 0xA3, (byte) 0xA4, (byte) 0xA5,
          (byte) 0xA6, (byte) 0xA7, (byte) 0xA8, (byte) 0xA9, (byte) 0xAA, (byte) 0xB2, (byte) 0xB3, (byte) 0xB4,
          (byte) 0xB5, (byte) 0xB6, (byte) 0xB7, (byte) 0xB8, (byte) 0xB9, (byte) 0xBA, (byte) 0xC2, (byte) 0xC3,
          (byte) 0xC4, (byte) 0xC5, (byte) 0xC6, (byte) 0xC7, (byte) 0xC8, (byte) 0xC9, (byte) 0xCA, (byte) 0xD2,
          (byte) 0xD3, (byte) 0xD4, (byte) 0xD5, (byte) 0xD6, (byte) 0xD7, (byte) 0xD8, (byte) 0xD9, (byte) 0xDA,
          (byte) 0xE2, (byte) 0xE3, (byte) 0xE4, (byte) 0xE5, (byte) 0xE6, (byte) 0xE7, (byte) 0xE8, (byte) 0xE9,
          (byte) 0xEA, (byte) 0xF2, (byte) 0xF3, (byte) 0xF4, (byte) 0xF5, (byte) 0xF6, (byte) 0xF7, (byte) 0xF8,
          (byte) 0xF9, (byte) 0xFA
      };
  
      @NotNull
      protected final List<HuffmanTable> tables = new ArrayList<HuffmanTable>(4);
  
      @NotNull
      private static final HashMap<Integer, String> _tagNameMap = new HashMap<Integer, String>();
  
      static
      {
          _tagNameMap.put(TAG_NUMBER_OF_TABLES, "Number of Tables");
      }
  
      public HuffmanTablesDirectory()
      {
          this.setDescriptor(new HuffmanTablesDescriptor(this));
      }
  
      @Override
      @NotNull
      public String getName()
      {
          return "Huffman";
      }
  
      @Override
      @NotNull
      protected HashMap<Integer, String> getTagNameMap()
      {
          return _tagNameMap;
      }
  
      /**
       * @param tableNumber The zero-based index of the table. This number is normally between 0 and 3.
       *                    Use {@link #getNumberOfTables} for bounds-checking.
       * @return The {@link HuffmanTable} having the specified number.
       */
      @NotNull
      public HuffmanTable getTable(int tableNumber)
      {
          return tables.get(tableNumber);
      }
  
      /**
       * @return The number of Huffman tables held by this {@link HuffmanTablesDirectory} instance.
       */
      public int getNumberOfTables() throws MetadataException
      {
          return getInt(HuffmanTablesDirectory.TAG_NUMBER_OF_TABLES);
      }
  
      /**
       * @return The {@link List} of {@link HuffmanTable}s in this
       * {@link Directory}.
       */
      @NotNull
      protected List<HuffmanTable> getTables()
      {
          return tables;
      }
  
      /**
       * Evaluates whether all the tables in this {@link HuffmanTablesDirectory}
       * are "typical" Huffman tables.
       * <p>
       * "Typical" has a special meaning in this context as the JPEG standard
       * (ISO/IEC 10918 or ITU-T T.81) defines 4 Huffman tables that has been
       * developed from the average statistics of a large set of images with 8-bit
       * precision. Using these instead of calculating the optimal Huffman tables
       * for a given image is faster, and is preferred by many hardware encoders
       * and some hardware decoders.
       * <p>
       * Even though the JPEG standard doesn't define these as "standard tables"
       * and requires a decoder to be able to read any valid Huffman tables, some
       * are in reality limited decoding images using these "typical" tables.
       * Standards like DCF (Design rule for Camera File system) and DLNA (Digital
       * Living Network Alliance) actually requires any compliant JPEG to use only
       * the "typical" Huffman tables.
       * <p>
       * This is also related to the term "optimized" JPEG. An "optimized" JPEG is
       * a JPEG that doesn't use the "typical" Huffman tables.
       *
       * @return Whether or not all the tables in this
       *         {@link HuffmanTablesDirectory} are the predefined "typical"
       *         Huffman tables.
       */
      public boolean isTypical()
      {
          if (tables.size() == 0) {
              return false;
          }
          for (HuffmanTable table : tables) {
              if (!table.isTypical()) {
                  return false;
              }
          }
          return true;
      }
  
      /**
       * The opposite of {@link #isTypical()}.
       *
       * @return Whether or not the tables in this {@link HuffmanTablesDirectory}
       *         are "optimized" - which means that at least one of them aren't
       *         one of the "typical" Huffman tables.
       */
      public boolean isOptimized()
      {
          return !isTypical();
      }
  
      /**
       * An instance of this class holds a JPEG Huffman table.
       */
      public static class HuffmanTable
      {
          private final int _tableLength;
          private final HuffmanTableClass _tableClass;
          private final int _tableDestinationId;
          private final byte[] _lengthBytes;
          private final byte[] _valueBytes;
  
          @SuppressWarnings("ConstantConditions")
          public HuffmanTable(
              @NotNull HuffmanTableClass tableClass,
              int tableDestinationId,
              @NotNull byte[] lengthBytes,
              @NotNull byte[] valueBytes)
          {
              if (lengthBytes == null)
                  throw new IllegalArgumentException("lengthBytes cannot be null.");
              if (valueBytes == null)
                  throw new IllegalArgumentException("valueBytes cannot be null.");
  
              _tableClass = tableClass;
              _tableDestinationId = tableDestinationId;
              _lengthBytes = lengthBytes;
              _valueBytes = valueBytes;
              _tableLength = _valueBytes.length + 17;
          }
  
          /**
           * @return The table length in bytes.
           */
          public int getTableLength()
          {
              return _tableLength;
          }
  
          /**
           * @return The {@link HuffmanTableClass} of this table.
           */
          public HuffmanTableClass getTableClass()
          {
              return _tableClass;
          }
  
          /**
           * @return the the destination identifier for this table.
           */
          public int getTableDestinationId()
          {
              return _tableDestinationId;
          }
  
          /**
           * @return A byte array with the L values for this table.
           */
          @NotNull
          public byte[] getLengthBytes()
          {
              byte[] result = new byte[_lengthBytes.length];
              System.arraycopy(_lengthBytes, 0, result, 0, _lengthBytes.length);
              return result;
          }
  
          /**
           * @return A byte array with the V values for this table.
           */
          @NotNull
          public byte[] getValueBytes()
          {
              byte[] result = new byte[_valueBytes.length];
              System.arraycopy(_valueBytes, 0, result, 0, _valueBytes.length);
              return result;
          }
  
          /**
           * Evaluates whether this table is a "typical" Huffman table.
           * <p>
           * "Typical" has a special meaning in this context as the JPEG standard
           * (ISO/IEC 10918 or ITU-T T.81) defines 4 Huffman tables that has been
           * developed from the average statistics of a large set of images with
           * 8-bit precision. Using these instead of calculating the optimal
           * Huffman tables for a given image is faster, and is preferred by many
           * hardware encoders and some hardware decoders.
           * <p>
           * Even though the JPEG standard doesn't define these as
           * "standard tables" and requires a decoder to be able to read any valid
           * Huffman tables, some are in reality limited decoding images using
           * these "typical" tables. Standards like DCF (Design rule for Camera
           * File system) and DLNA (Digital Living Network Alliance) actually
           * requires any compliant JPEG to use only the "typical" Huffman tables.
           * <p>
           * This is also related to the term "optimized" JPEG. An "optimized"
           * JPEG is a JPEG that doesn't use the "typical" Huffman tables.
           *
           * @return Whether or not this table is one of the predefined "typical"
           *         Huffman tables.
           */
          public boolean isTypical()
          {
              if (_tableClass == HuffmanTableClass.DC) {
                  return
                      Arrays.equals(_lengthBytes, TYPICAL_LUMINANCE_DC_LENGTHS) &&
                      Arrays.equals(_valueBytes, TYPICAL_LUMINANCE_DC_VALUES) ||
                      Arrays.equals(_lengthBytes, TYPICAL_CHROMINANCE_DC_LENGTHS) &&
                      Arrays.equals(_valueBytes, TYPICAL_CHROMINANCE_DC_VALUES);
              } else if (_tableClass == HuffmanTableClass.AC) {
                  return
                      Arrays.equals(_lengthBytes, TYPICAL_LUMINANCE_AC_LENGTHS) &&
                      Arrays.equals(_valueBytes, TYPICAL_LUMINANCE_AC_VALUES) ||
                      Arrays.equals(_lengthBytes, TYPICAL_CHROMINANCE_AC_LENGTHS) &&
                      Arrays.equals(_valueBytes, TYPICAL_CHROMINANCE_AC_VALUES);
              }
              return false;
          }
  
          /**
           * The opposite of {@link #isTypical()}.
           *
           * @return Whether or not this table is "optimized" - which means that
           *         it isn't one of the "typical" Huffman tables.
           */
          public boolean isOptimized()
          {
              return !isTypical();
          }
  
          public enum HuffmanTableClass
          {
              DC,
              AC,
              UNKNOWN;
  
              public static HuffmanTableClass typeOf(int value)
              {
                  switch (value) {
                      case 0:
                          return DC;
                      case 1:
                          return AC;
                      default:
                          return UNKNOWN;
                  }
              }
          }
      }
  }
  