/*

 * Copyright 2016 Intel Corporation

 *

 * 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.

 *

 * ----

 *

 * Part of IJG's libjpeg library (primarily jdmarker.c) was used as a reference

 * while implementing this parser.  This implementation loosely reproduces some

 * of the parsing logic found in the libjpeg jdmarker.c file.  Although, this

 * logic has been refactored using C++-style syntax and data structures and

 * adjusted appropriately to fit into the overall libyami framework.  Therefore,

 * this implementation is considered to be partially derived from IJG's libjpeg.

 *

 * The following license preamble, below, is reproduced from libjpeg's

 * jdmarker.c file.  The README.ijg is also provided with this file:

 *

 * Copyright (C) 1991-1998, Thomas G. Lane.

 * Modified 2009-2013 by Guido Vollbeding.

 * The jdmarker.c file is part of the Independent JPEG Group's software.

 * For conditions of distribution and use, see the accompanying README.ijg file.

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

// primary header

#include "jpegParser.h"

// library headers

#include "common/log.h"

// system headers

#include <algorithm>

#include <cstring>

namespace YamiParser {

namespace JPEG {

#define INPUT_BYTE(var, action) \

    do { \

        if (m_input.end()) { \

            action; \

        } \

        var = m_input.read(8); \

    } while(0)

#define INPUT_2BYTES(var, action) \

    do { \

        uint16_t b1, b2; \

        INPUT_BYTE(b1, action); \

        INPUT_BYTE(b2, action); \

        var = ((b1 << 8) | b2) & 0xffff; \

    } while(0)

const Defaults Defaults::s_instance;

Defaults::Defaults()

    : m_acHuffTables()

    , m_dcHuffTables()

    , m_quantTables()

{

    // The following tables are from

    // https://www.w3.org/Graphics/JPEG/itu-t81.pdf

    { // K.3.3.1 Luminance DC coefficients

        std::array<uint8_t, 16> codes = {

            0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,

            0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

        };

        std::array<uint8_t, 256> values = {

            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,

            0x08, 0x09, 0x0a, 0x0b

        };

        m_dcHuffTables[0].reset(new HuffTable());

        m_dcHuffTables[0]->codes.swap(codes);

        m_dcHuffTables[0]->values.swap(values);

    }

    { // K.3.3.1 Chrominance DC coefficients

        std::array<uint8_t, 16> codes = {

            0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

            0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00

        };

        std::array<uint8_t, 256> values = {

            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,

            0x08, 0x09, 0x0a, 0x0b

        };

        m_dcHuffTables[1].reset(new HuffTable());

        m_dcHuffTables[1]->codes.swap(codes);

        m_dcHuffTables[1]->values.swap(values);

    }

    { // K.3.3.2 Luminance AC coefficients

        std::array<uint8_t, 16> codes = {

            0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03,

            0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d

        };

        std::array<uint8_t, 256> 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

        };

        m_acHuffTables[0].reset(new HuffTable());

        m_acHuffTables[0]->codes.swap(codes);

        m_acHuffTables[0]->values.swap(values);

    }

    { // K.3.3.2 Chrominance AC coefficients

        std::array<uint8_t, 16> codes = {

            0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,

            0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77

        };

        std::array<uint8_t, 256> 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

        };

        m_acHuffTables[1].reset(new HuffTable());

        m_acHuffTables[1]->codes.swap(codes);

        m_acHuffTables[1]->values.swap(values);

    }

    static const std::array<uint8_t, 64> zigzag8x8 = {

        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

    };

    { // Table K.1 Luminance quantization table values

        std::array<uint16_t, DCTSIZE2> values = {

            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

        };

        m_quantTables[0].reset(new QuantTable());

        for (size_t i(0); i < DCTSIZE2; ++i)

            m_quantTables[0]->values[i] = values[zigzag8x8[i]];

        m_quantTables[0]->precision = 0; // 1-byte precision

    }

    { // Table K.2 Chrominance quantization table values

        std::array<uint16_t, DCTSIZE2> values = {

            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

        };

        m_quantTables[1].reset(new QuantTable());

        for (size_t i(0); i < DCTSIZE2; ++i)

            m_quantTables[1]->values[i] = values[zigzag8x8[i]];

        m_quantTables[1]->precision = 0; // 1-byte precision

    }

}

Parser::Parser(const uint8_t* data, const uint32_t size)

    : m_input(data, size)

    , m_data(data)

    , m_size(size)

    , m_current()

    , m_frameHeader()

    , m_scanHeader()

    , m_quantTables()

    , m_dcHuffTables()

    , m_acHuffTables()

    , m_arithDCL()

    , m_arithDCU()

    , m_arithACK()

    , m_callbacks()

    , m_sawSOI(false)

    , m_sawEOI(false)

    , m_sawSOS(false)

    , m_restartInterval(0)

{

}

bool Parser::skipBytes(const uint32_t nBytes)

{

    if ((static_cast<uint64_t>(nBytes) << 3)

            > m_input.getRemainingBitsCount()) {

        ERROR("Not enough bytes in stream");

        return false;

    }

    // BitReader only supports skipping a max of CACHEBYTES at a time

    // for each call to skip.

    const uint32_t nSkips = nBytes / BitReader::CACHEBYTES;

    const uint32_t rem = nBytes % BitReader::CACHEBYTES;

    for (uint32_t i(0); i < nSkips; ++i)

        m_input.skip(BitReader::CACHEBYTES << 3);

    m_input.skip(rem << 3);

    return true;

}

void Parser::registerCallback(const Marker& marker, const Callback& callback)

{

    m_callbacks[marker].push_back(callback);

}

void Parser::registerStartOfFrameCallback(const Callback& callback)

{

    static const std::array<const Marker, 13> sofMarkers = {

        M_SOF0, M_SOF1 , M_SOF2 , M_SOF3 , M_SOF5 , M_SOF6 , M_SOF7,

        M_SOF9, M_SOF10, M_SOF11, M_SOF13, M_SOF14, M_SOF15 };

    for (size_t i(0); i < 13; ++i)

        registerCallback(sofMarkers[i], callback);

}

Parser::CallbackResult Parser::notifyCallbacks() const

{

    const Callbacks::const_iterator match(m_callbacks.find(m_current.marker));

    if (match != m_callbacks.end()) {

        const CallbackList& callbacks = match->second;

        const size_t nCallbacks = callbacks.size();

        for (size_t i(0); i < nCallbacks; ++i)

            if (callbacks[i]() == ParseSuspend)

                return ParseSuspend;

    }

    return ParseContinue;

}

bool Parser::firstMarker()

{

    uint32_t c, c2;

    INPUT_BYTE(c, return false);

    INPUT_BYTE(c2, return false);

    if (c != 0xFF || c2 != M_SOI) {

        ERROR("No SOI found. Not a JPEG");

        return false;

    }

    m_current.marker = static_cast<Marker>(c2);

    m_current.position = currentBytePosition() - 1;

    m_current.length = 0; // set by marker parse routines when appropriate

    return true;

}

bool Parser::nextMarker()

{

    if (m_input.getRemainingBitsCount() == 0)

        return false;

    const uint8_t* const end = m_data + m_size - 1;

    const uint8_t* const start = m_data + currentBytePosition();

    const uint8_t* current = start;

    const uint8_t* match;

    do {

        match = std::find(current, end, 0xFF);

        if (match == end) {

            skipBytes(std::distance(start, match) + 1);

            return false;

        }

        if (*(match + 1) < 0xFF && *(match + 1) >= M_SOF0)

            break;

        current = match + 1;

    } while (true);

    skipBytes(std::distance(start, match) + 1);

    m_current.marker = static_cast<Marker>(m_input.read(8));

    m_current.position = currentBytePosition() - 1;

    m_current.length = 0; // set by marker parse routines when appropriate

    return true;

}

bool Parser::parse()

{

    while (true) {

        if (!m_sawSOI) {

            if (!firstMarker()) {

                return false;

            }

        } else if (!nextMarker()) {

            if (m_sawSOS && !m_sawEOI) {

                // NOTE: By standard, a missing EOI technically means the image

                // is corrupt.  However, there are many images in the wild where

                // a missing EOI is the only corruption to the image (i.e. the

                // entropy-coded data and headers are still intact).  This can

                // happen, for example, when the image was encoded by a buggy

                // application that forgets to append the EOI to the final

                // image.  If a missing EOI is the only issue, then decoders can

                // still successfully decode it.  However, a missing EOI does

                // not necessarily mean the rest of the image is intact.  That

                // is, there is no guarantee that the final decoded output will

                // produce the desired result.  Either way, we insert a fake

                // EOI marker here to give decoders a chance to decode the

                // image.

                WARNING("No EOI marker found on input... inserting one now");

                m_current.marker = M_EOI;

                m_current.position = currentBytePosition() - 1;

                m_current.length = 0;

            } else {

                return m_sawEOI;

            }

        }

        DEBUG("%s (byte:0x%02x position:%u)", __func__,

            m_current.marker, m_current.position);

        bool parseSegment = false;

        switch (m_current.marker) {

        case M_SOI:

            parseSegment = parseSOI();

            break;

        case M_SOF0: // Baseline

            parseSegment = parseSOF(true, false, false);

            break;

        case M_SOF1: // Extended sequential, Huffman

            parseSegment = parseSOF(false, false, false);

            break;

        case M_SOF2: // Progressive, Huffman

            parseSegment = parseSOF(false, true, false);

            break;

        case M_SOF9: // Extended sequential, arithmetic

            parseSegment = parseSOF(false, false, true);

            break;

        case M_SOF10: // Progressive, arithmetic

            parseSegment = parseSOF(false, true, true);

            break;

        case M_DAC:

            parseSegment = parseDAC();

            break;

        case M_DHT:

            parseSegment = parseDHT();

            break;

        case M_DQT:

            parseSegment = parseDQT();

            break;

        case M_DRI:

            parseSegment = parseDRI();

            break;

        case M_SOS:

            parseSegment = parseSOS();

            break;

        case M_EOI:

            parseSegment = parseEOI();

            break;

        case M_APP0:

        case M_APP1:

        case M_APP2:

        case M_APP3:

        case M_APP4:

        case M_APP5:

        case M_APP6:

        case M_APP7:

        case M_APP8:

        case M_APP9:

        case M_APP10:

        case M_APP11:

        case M_APP12:

        case M_APP13:

        case M_APP14:

        case M_APP15:

            parseSegment = parseAPP();

            break;

        case M_COM:

        case M_RST0:

        case M_RST1:

        case M_RST2:

        case M_RST3:

        case M_RST4:

        case M_RST5:

        case M_RST6:

        case M_RST7:

            parseSegment = true;

            break;

        /* Currently unsupported SOFn types */

        case M_SOF3:  // Lossless, Huffman

        case M_SOF5:  // Differential sequential, Huffman

        case M_SOF6:  // Differential progressive, Huffman

        case M_SOF7:  // Differential lossless, Huffman

        case M_JPG:   // Reserved for JPEG extensions

        case M_SOF11: // Lossless, arithmetic

        case M_SOF13: // Differential sequential, arithmetic

        case M_SOF14: // Differential progressive, arithmetic

        case M_SOF15: // Differential lossless, arithmetic

            //unsupported

            ERROR("Unsupported marker encountered: 0x%02x", m_current.marker);

            return false;

        default:

            // unknown or unhandled marker

            ERROR("Unknown or unhandled marker: 0x%02x", m_current.marker);

            return false;

        }

        if (!parseSegment)

            return false;

        if (notifyCallbacks() == ParseSuspend)

            return true;

    }

}

bool Parser::parseSOI()

{

    if (m_sawSOI) {

        ERROR("Duplicate SOI encountered");

        return false;

    }

    m_sawSOI = true;

    return true;

}

bool Parser::parseAPP()

{

    INPUT_2BYTES(m_current.length, return false);

    return skipBytes(m_current.length - 2);

}

bool Parser::parseSOF(bool isBaseline, bool isProgressive, bool isArithmetic)

{

    if (m_frameHeader) {

        ERROR("Duplicate SOF encountered");

        return false;

    }

    INPUT_2BYTES(m_current.length, return false);

    m_frameHeader.reset(new FrameHeader);

    m_frameHeader->isBaseline = isBaseline;

    m_frameHeader->isProgressive = isProgressive;

    m_frameHeader->isArithmetic = isArithmetic;

    INPUT_BYTE(m_frameHeader->dataPrecision, return false);

    INPUT_2BYTES(m_frameHeader->imageHeight, return false);

    INPUT_2BYTES(m_frameHeader->imageWidth, return false);

    uint32_t numComponents;

    INPUT_BYTE(numComponents, return false);

    DEBUG("baseline      : %d", m_frameHeader->isBaseline);

    DEBUG("progressive   : %d", m_frameHeader->isProgressive);

    DEBUG("arithmetic    : %d", m_frameHeader->isArithmetic);

    DEBUG("precision     : %d", m_frameHeader->dataPrecision);

    DEBUG("image width   : %u", m_frameHeader->imageWidth);

    DEBUG("image height  : %u", m_frameHeader->imageHeight);

    DEBUG("num components: %d", numComponents);

    if (m_frameHeader->imageWidth <= 0 || m_frameHeader->imageHeight <= 0

            || numComponents <= 0) {

        ERROR("Empty image");

        return false;

    }

    if ((m_current.length - 8) != (numComponents * 3)

            || numComponents > MAX_COMPS_IN_SCAN) {

        ERROR("Bad length");

        return false;

    }

    m_frameHeader->components.resize(numComponents);

    m_frameHeader->maxHSampleFactor = 0;

    m_frameHeader->maxVSampleFactor = 0;

    for (size_t index(0); index < numComponents; ++index) {

        int factor;

        Component::Shared& component = m_frameHeader->components[index];

        component.reset(new Component);

        component->index = index;

        INPUT_BYTE(component->id, return false);

        INPUT_BYTE(factor, return false);

        component->hSampleFactor = (factor >> 4) & 15;

        component->vSampleFactor = factor & 15;

        if (component->hSampleFactor > m_frameHeader->maxHSampleFactor)

            m_frameHeader->maxHSampleFactor = component->hSampleFactor;

        if (component->vSampleFactor > m_frameHeader->maxVSampleFactor)

            m_frameHeader->maxVSampleFactor = component->vSampleFactor;

        INPUT_BYTE(component->quantTableNumber, return false);

    }

    return true;

}

static bool componentIdMatches(const int id, const Component::Shared& component)

{

    return id == component->id;

}

bool Parser::parseSOS()

{

    using std::placeholders::_1;

    if (!m_frameHeader) {

        ERROR("SOS Encountered before SOF");

        return false;

    }

    INPUT_2BYTES(m_current.length, return false);

    size_t numComponents;

    INPUT_BYTE(numComponents, return false);

    if (m_current.length != (numComponents * 2 + 6)

            || numComponents < 1

            || numComponents > MAX_COMPS_IN_SCAN) {

        ERROR("Invalid SOS Length");

        return false;

    }

    m_scanHeader.reset(new ScanHeader);

    m_scanHeader->numComponents = numComponents;

    for (size_t i(0); i < numComponents; ++i)

        m_scanHeader->components[i].reset();

    for (size_t i(0); i < numComponents; ++i) {

        int id;

        int c;

        INPUT_BYTE(id, return false);

        Components::iterator component = std::find_if(

            m_frameHeader->components.begin(),

            m_frameHeader->components.end(),

            std::bind(&componentIdMatches, id, _1));

        if (component == m_frameHeader->components.end()

                || m_scanHeader->components[(*component)->index]) {

            ERROR("Bad Component Id (%d)", id);

            return false;

        }

        INPUT_BYTE(c, return false);

        m_scanHeader->components[i] = *component;

        (*component)->dcTableNumber = (c >> 4) & 15;

        (*component)->acTableNumber = c & 15;

        /* This CSi (cc) should differ from the previous CSi */

        for (size_t pi(0); pi < i; ++pi) {

            if (m_scanHeader->components[pi] == (*component)) {

                ERROR("Bad Component Id (%d)", id);

                return false;

            }

        }

    }

    // The following are used only in progressive mode

    // FIXME: validate these values according to JPEG specification

    INPUT_BYTE(m_scanHeader->ss, return false);

    INPUT_BYTE(m_scanHeader->se, return false);

    INPUT_BYTE(m_scanHeader->ah, return false);

    m_scanHeader->al = m_scanHeader->ah & 15;

    m_scanHeader->ah = (m_scanHeader->ah >> 4) & 15;

    m_sawSOS = true;

    return true;

}

bool Parser::parseEOI()

{

    if (m_sawEOI) {

        ERROR("Duplicate EOI encountered");

        return false;

    }

    m_sawEOI = true;

    return true;

}

bool Parser::parseDAC()

{

    INPUT_2BYTES(m_current.length, return false);

    long length = m_current.length - 2;

    while (length > 0) {

        size_t index;

        int value;

        INPUT_BYTE(index, return false);

        INPUT_BYTE(value, return false);

        length -= 2;

        if (index < 0 || index >= (2 * NUM_ARITH_TBLS)) {

            ERROR("Invalid DAC Index");

            return false;

        }

        if (index >= NUM_ARITH_TBLS) {

            m_arithACK[index - NUM_ARITH_TBLS] = value;

        } else {

            m_arithDCL[index] = value & 15;

            m_arithDCU[index] = (value >> 4) & 15;

            if (m_arithDCL[index] > m_arithDCU[index]) {

                ERROR("Invalid DAC Value");

                return false;

            }

        }

    }

    if (length != 0) {

        ERROR("Invalid DAC Length");

        return false;

    }

    return true;

}

bool Parser::parseDQT()

{

    INPUT_2BYTES(m_current.length, return false);

    long length = m_current.length - 2;

    while (length > 0) {

        int c;

        INPUT_BYTE(c, return false);

        const size_t index = c & 15;

        const int precision = (c >> 4) & 15;

        if (index >= NUM_QUANT_TBLS) {

            ERROR("Invalid quant table index encountered");

            return false;

        }

        QuantTable::Shared& quantTable = m_quantTables[index];

        if (!quantTable)

            quantTable.reset(new QuantTable);

        quantTable->precision = precision;

        for (size_t i(0); i < DCTSIZE2; ++i) {

            if (precision)

                INPUT_2BYTES(quantTable->values[i], return false);

            else

                INPUT_BYTE(quantTable->values[i], return false);

        }

        const uint32_t nbytes = precision ? 2 : 1;

        length -= (DCTSIZE2 * nbytes) + 1;

    }

    if (length != 0) {

        ERROR("Bad DQT length");

        return false;

    }

    return true;

}

bool Parser::parseDHT()

{

    INPUT_2BYTES(m_current.length, return false);

    long length = m_current.length - 2;

    while (length > 16) {

        size_t index;

        INPUT_BYTE(index, return false);

        long count = 0;

        std::vector<uint8_t> codes(16, 0);

        for (size_t i(0); i < 16; ++i) {

            INPUT_BYTE(codes[i], return false);

            count += codes[i];

        }

        length -= 1 + 16;

        if (count > 256 || count > length) {

            ERROR("Bad Huff Table");

            return false;

        }

        std::vector<uint8_t> huffval(256, 0);

        for (long i(0); i < count; ++i)

            INPUT_BYTE(huffval[i], return false);

        length -= count;

        HuffTables* huffTables;

        if (index & 0x10) { /* AC table definition */

            index -= 0x10;

            huffTables = &m_acHuffTables;

        } else { /* DC table definition */

            huffTables = &m_dcHuffTables;

        }

        if (index < 0 || index >= NUM_HUFF_TBLS) {

            ERROR("Bad Huff Table Index");

            return false;

        }

        HuffTable::Shared& huffTable = (*huffTables)[index];

        if (!huffTable)

            huffTable.reset(new HuffTable);

        std::memcpy(&huffTable->codes[0], &codes[0],

                    sizeof(huffTable->codes));

        std::memcpy(&huffTable->values[0], &huffval[0],

                    sizeof(huffTable->values));

    }

    if (length != 0) {

        ERROR("Bad DHT Length");

        return false;

    }

    return true;

}

bool Parser::parseDRI()

{

    INPUT_2BYTES(m_current.length, return false);

    if (m_current.length != 4) {

        ERROR("Bad DRI Length");

        return false;

    }

    INPUT_2BYTES(m_restartInterval, return false);

    return true;

}

} // namespace JPEG

} // namespace YamiParser