/* INTEL CONFIDENTIAL
* Copyright (c) 2012 Intel Corporation.  All rights reserved.
* Copyright (c) Imagination Technologies Limited, UK
*
* The source code contained or described herein and all documents
* related to the source code ("Material") are owned by Intel
* Corporation or its suppliers or licensors.  Title to the
* Material remains with Intel Corporation or its suppliers and
* licensors.  The Material contains trade secrets and proprietary
* and confidential information of Intel or its suppliers and
* licensors. The Material is protected by worldwide copyright and
* trade secret laws and treaty provisions.  No part of the Material
* may be used, copied, reproduced, modified, published, uploaded,
* posted, transmitted, distributed, or disclosed in any way without
* Intel's prior express written permission.
*
* No license under any patent, copyright, trade secret or other
* intellectual property right is granted to or conferred upon you
* by disclosure or delivery of the Materials, either expressly, by
* implication, inducement, estoppel or otherwise. Any license
* under such intellectual property rights must be express and
* approved by Intel in writing.
*
* Authors:
*    Nana Guo <nana.n.guo@intel.com>
*
*/

#include "va/va_tpi.h"
#include "JPEGDecoder.h"
#include "ImageDecoderTrace.h"
#include "JPEGParser.h"
#include <string.h>

#define JPEG_MAX_SETS_HUFFMAN_TABLES 2

#define TABLE_CLASS_DC  0
#define TABLE_CLASS_AC  1
#define TABLE_CLASS_NUM 2

/*
 * Initialize VA API related stuff
 *
 * We will check the return value of  jva_initialize
 * to determine which path will be use (SW or HW)
 *
 */
Decode_Status jdva_initialize (jd_libva_struct * jd_libva_ptr) {
  /*
   * Please note that we won't check the input parameters to follow the
   * convention of libjpeg duo to we need these parameters to do error handling,
   * and if these parameters are invalid, means the whole stack is crashed, so check
   * them here and return false is meaningless, same situation for all internal methods
   * related to VA API
  */
    int va_major_version;
    int va_minor_version;
#if 0
    int va_max_num_profiles, va_max_num_entrypoints, va_max_num_attribs;
    int va_num_profiles,  va_num_entrypoints;

    VAProfile *va_profiles = NULL;
    VAEntrypoint *va_entrypoints = NULL;
#endif
    VAStatus va_status = VA_STATUS_SUCCESS;
    Decode_Status status = DECODE_SUCCESS;
    int index;

    if (jd_libva_ptr->initialized)
        return DECODE_NOT_STARTED;

    jd_libva_ptr->android_display = (Display*)malloc(sizeof(Display));
    if (jd_libva_ptr->android_display == NULL) {
        return DECODE_MEMORY_FAIL;
    }
    jd_libva_ptr->va_display = vaGetDisplay (jd_libva_ptr->android_display);

    if (jd_libva_ptr->va_display == NULL) {
        ETRACE("vaGetDisplay failed.");
        free (jd_libva_ptr->android_display);
        return DECODE_DRIVER_FAIL;
    }
    va_status = vaInitialize(jd_libva_ptr->va_display, &va_major_version, &va_minor_version);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaInitialize failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        goto cleanup;
    }
#if 0
    /*get the max number for profiles/entrypoints/attribs*/
    va_max_num_profiles = vaMaxNumProfiles(jd_libva_ptr->va_display);
    va_max_num_entrypoints = vaMaxNumEntrypoints(jd_libva_ptr->va_display);
    va_max_num_attribs = vaMaxNumConfigAttributes(jd_libva_ptr->va_display);

    va_profiles = malloc (sizeof(VAProfile)*va_max_num_profiles);
    va_entrypoints = malloc(sizeof(VAEntrypoint)*va_max_num_entrypoints);

    if (va_profiles == NULL || va_entrypoints ==NULL) {
        jd_libva_ptr->initialized = TRUE; // make sure we can call into jva_deinitialize()
        jdva_deinitialize (jd_libva_ptr);
        return DECODE_MEMORY_FAIL;
    }

    va_status = vaQueryConfigProfiles (jd_libva_ptr->va_display, va_profiles, &va_num_profiles);

    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaQueryConfigProfiles failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        goto cleanup;
    }

    /*check whether profile is supported*/
    for(index= 0; index < va_num_profiles; index++) {
        if(VAProfileJPEGBaseline == va_profiles[index])
            break;
    }

    if(index == va_num_profiles) {
        WTRACE("Profile not surportted\n");
        status = DECODE_FAIL;
        goto cleanup;

    }

    va_status = vaQueryConfigEntrypoints(jd_libva_ptr->va_display, VAProfileJPEGBaseline, va_entrypoints, &va_num_entrypoints);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaQueryConfigProfiles failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        goto cleanup;
    }
    /* traverse entrypoints arrary to see whether VLD is there */
    for (index = 0; index < va_num_entrypoints; index ++) {
        if (va_entrypoints[index] == VAEntrypointVLD)
            break;
    }
#endif
    VAConfigAttrib attrib;
    attrib.type = VAConfigAttribRTFormat;
    va_status = vaGetConfigAttributes(jd_libva_ptr->va_display, VAProfileJPEGBaseline, VAEntrypointVLD, &attrib, 1);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaGetConfigAttributes failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        goto cleanup;
    }
    if ((VA_RT_FORMAT_YUV444 & attrib.value) == 0) {
        WTRACE("Format not surportted\n");
        status = DECODE_FAIL;
        goto cleanup;
    }

    va_status = vaCreateConfig(jd_libva_ptr->va_display, VAProfileJPEGBaseline, VAEntrypointVLD, &attrib, 1, &(jd_libva_ptr->va_config));
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaCreateConfig failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        goto cleanup;
    }
    jd_libva_ptr->initialized = TRUE;
    status = DECODE_SUCCESS;

cleanup:
#if 0
    /*free profiles and entrypoints*/
    if (va_profiles)
        free(va_profiles);

    if (va_entrypoints)
        free (va_entrypoints);
#endif
    if (!status) {
        jd_libva_ptr->initialized = TRUE; // make sure we can call into jva_deinitialize()
        jdva_deinitialize (jd_libva_ptr);
        return status;
    }

  return status;
}

void jdva_deinitialize (jd_libva_struct * jd_libva_ptr) {
    if (!(jd_libva_ptr->initialized)) {
        return;
    }

    if (jd_libva_ptr->JPEGParser) {
        free(jd_libva_ptr->JPEGParser);
        jd_libva_ptr->JPEGParser = NULL;
    }

    if (jd_libva_ptr->va_display) {
        vaTerminate(jd_libva_ptr->va_display);
        jd_libva_ptr->va_display = NULL;
    }

    if (jd_libva_ptr->android_display) {
        free(jd_libva_ptr->android_display);
        jd_libva_ptr->android_display = NULL;
    }

    jd_libva_ptr->initialized = FALSE;
    return;
}

Decode_Status jdva_create_resource (jd_libva_struct * jd_libva_ptr) {
    VAStatus va_status = VA_STATUS_SUCCESS;
    Decode_Status status;
    jd_libva_ptr->image_width = jd_libva_ptr->picture_param_buf.picture_width;
    jd_libva_ptr->image_height = jd_libva_ptr->picture_param_buf.picture_height;
    jd_libva_ptr->surface_count = 1;
    jd_libva_ptr->va_surfaces = (VASurfaceID *) malloc(sizeof(VASurfaceID)*jd_libva_ptr->surface_count);
    if (jd_libva_ptr->va_surfaces == NULL) {
        return DECODE_MEMORY_FAIL;
    }
    va_status = vaCreateSurfaces(jd_libva_ptr->va_display, VA_RT_FORMAT_YUV444,
                                    (((jd_libva_ptr->image_width + 7) & (~7)) + 15) & (~15),
                                    (((jd_libva_ptr->image_width + 7) & (~7)) + 15) & (~15),
                                    jd_libva_ptr->va_surfaces,
                                    jd_libva_ptr->surface_count, NULL, 0);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaCreateSurfaces failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        goto cleanup;
    }
    va_status = vaCreateContext(jd_libva_ptr->va_display, jd_libva_ptr->va_config,
                                   (( ( jd_libva_ptr->image_width + 7 ) & ( ~7 )) + 15 ) & ( ~15 ),
                                   ((( jd_libva_ptr->image_height + 7 ) & ( ~7 )) + 15 ) & ( ~15 ),
                                   0,  //VA_PROGRESSIVE
                                   jd_libva_ptr->va_surfaces,
                                   jd_libva_ptr->surface_count, &(jd_libva_ptr->va_context));

    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaCreateContext failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        goto cleanup;

    }
    jd_libva_ptr->resource_allocated = TRUE;
    return status;
cleanup:

    if (jd_libva_ptr->va_surfaces) {
        free (jd_libva_ptr->va_surfaces);
        jd_libva_ptr->va_surfaces = NULL;
    }
    jdva_deinitialize (jd_libva_ptr);

    return status;
}

Decode_Status jdva_release_resource (jd_libva_struct * jd_libva_ptr) {
    Decode_Status status = DECODE_SUCCESS;
    VAStatus va_status = VA_STATUS_SUCCESS;

    if (!(jd_libva_ptr->resource_allocated)) {
        return status;
    }

    if (!(jd_libva_ptr->va_display)) {
        return status; //most likely the resource are already released and HW jpeg is deinitialize, return directly
    }

  /*
   * It is safe to destroy Surface/Config/Context severl times
   * and it is also safe even their value is NULL
   */

    va_status = vaDestroySurfaces(jd_libva_ptr->va_display, jd_libva_ptr->va_surfaces, jd_libva_ptr->surface_count);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaDestroySurfaces failed. va_status = 0x%x", va_status);
        return DECODE_DRIVER_FAIL;
    }

    if (jd_libva_ptr->va_surfaces) {
        free (jd_libva_ptr->va_surfaces);
        jd_libva_ptr->va_surfaces = NULL;
    }

    va_status = vaDestroyConfig(jd_libva_ptr->va_display, jd_libva_ptr->va_config);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaDestroyConfig failed. va_status = 0x%x", va_status);
        return DECODE_DRIVER_FAIL;
    }

    jd_libva_ptr->va_config = NULL;

    va_status = vaDestroyContext(jd_libva_ptr->va_display, jd_libva_ptr->va_context);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaDestroyContext failed. va_status = 0x%x", va_status);
        return DECODE_DRIVER_FAIL;
    }

    jd_libva_ptr->va_context = NULL;

    jd_libva_ptr->resource_allocated = FALSE;

    return va_status;
}

Decode_Status jdva_decode (jd_libva_struct * jd_libva_ptr, uint8_t* buf) {
    Decode_Status status = DECODE_SUCCESS;
    VAStatus va_status = VA_STATUS_SUCCESS;
    VABufferID desc_buf[5];
    uint32_t bitstream_buffer_size;
    uint32_t scan_idx = 0;
    uint32_t buf_idx = 0;
    uint32_t chopping = VA_SLICE_DATA_FLAG_ALL;
    uint32_t bytes_remaining = jd_libva_ptr->file_size;
    uint32_t src_offset = 0;
    bitstream_buffer_size = 1024*512*5;

    va_status = vaBeginPicture(jd_libva_ptr->va_display, jd_libva_ptr->va_context, jd_libva_ptr->va_surfaces[0]);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaBeginPicture failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        return status;
    }
    va_status = vaCreateBuffer(jd_libva_ptr->va_display, jd_libva_ptr->va_context, VAPictureParameterBufferType, sizeof(VAPictureParameterBufferJPEG), 1, &jd_libva_ptr->picture_param_buf, &desc_buf[buf_idx]);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaCreateBuffer failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        return status;
    }
    buf_idx++;
    va_status = vaCreateBuffer(jd_libva_ptr->va_display, jd_libva_ptr->va_context, VAIQMatrixBufferType, sizeof(VAIQMatrixParameterBufferJPEG), 1, &jd_libva_ptr->qmatrix_buf, &desc_buf[buf_idx]);

    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaCreateBuffer failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        return status;
    }
    buf_idx++;
    va_status = vaCreateBuffer(jd_libva_ptr->va_display, jd_libva_ptr->va_context, VAHuffmanTableBufferType, sizeof(VAHuffmanTableParameterBufferJPEG), 1, &jd_libva_ptr->hufman_table_buf, &desc_buf[buf_idx]);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaCreateBuffer failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        return status;
    }
    buf_idx++;
    do {
        /* Get Bitstream Buffer */
        uint32_t bytes = ( bytes_remaining < bitstream_buffer_size ) ? bytes_remaining : bitstream_buffer_size;
        bytes_remaining -= bytes;
        /* Get Slice Control Buffer */
        VASliceParameterBufferJPEG dest_scan_ctrl[JPEG_MAX_COMPONENTS];
        uint32_t src_idx;
        uint32_t dest_idx = 0;
        memset(dest_scan_ctrl, 0, sizeof(dest_scan_ctrl));
        for (src_idx = scan_idx; src_idx < jd_libva_ptr->scan_ctrl_count ; src_idx++) {
            if (jd_libva_ptr->slice_param_buf[ src_idx ].slice_data_offset) {
                /* new scan, reset state machine */
                chopping = VA_SLICE_DATA_FLAG_ALL;
                fprintf(stderr,"Scan:%i FileOffset:%x Bytes:%x \n", src_idx,
                    jd_libva_ptr->slice_param_buf[ src_idx ].slice_data_offset,
                    jd_libva_ptr->slice_param_buf[ src_idx ].slice_data_size );
                /* does the slice end in the buffer */
                if (jd_libva_ptr->slice_param_buf[ src_idx ].slice_data_offset + jd_libva_ptr->slice_param_buf[ src_idx ].slice_data_size > bytes + src_offset) {
                    chopping = VA_SLICE_DATA_FLAG_BEGIN;
                }
            } else {
                if (jd_libva_ptr->slice_param_buf[ src_idx ].slice_data_size > bytes) {
                    chopping = VA_SLICE_DATA_FLAG_MIDDLE;
                } else {
                    if ((chopping == VA_SLICE_DATA_FLAG_BEGIN) || (chopping == VA_SLICE_DATA_FLAG_MIDDLE)) {
                        chopping = VA_SLICE_DATA_FLAG_END;
                    }
                }
            }
            dest_scan_ctrl[dest_idx].slice_data_flag = chopping;
            dest_scan_ctrl[dest_idx].slice_data_offset = ((chopping == VA_SLICE_DATA_FLAG_ALL) ||      (chopping == VA_SLICE_DATA_FLAG_BEGIN) )?
jd_libva_ptr->slice_param_buf[ src_idx ].slice_data_offset - src_offset : 0;

            const int32_t bytes_in_seg = bytes - dest_scan_ctrl[dest_idx].slice_data_offset;
            const uint32_t scan_data = (bytes_in_seg < jd_libva_ptr->slice_param_buf[src_idx].slice_data_size) ? bytes_in_seg : jd_libva_ptr->slice_param_buf[src_idx].slice_data_size ;
            jd_libva_ptr->slice_param_buf[src_idx].slice_data_offset = 0;
            jd_libva_ptr->slice_param_buf[src_idx].slice_data_size -= scan_data;
            dest_scan_ctrl[dest_idx].slice_data_size = scan_data;
            dest_scan_ctrl[dest_idx].num_components = jd_libva_ptr->slice_param_buf[src_idx].num_components;
            dest_scan_ctrl[dest_idx].restart_interval = jd_libva_ptr->slice_param_buf[src_idx].restart_interval;
            memcpy(&dest_scan_ctrl[dest_idx].components, & jd_libva_ptr->slice_param_buf[ src_idx ].components,
                sizeof(jd_libva_ptr->slice_param_buf[ src_idx ].components) );
            dest_idx++;
            if ((chopping == VA_SLICE_DATA_FLAG_ALL) || (chopping == VA_SLICE_DATA_FLAG_END)) { /* all good good */
            } else {
                break;
            }
        }
        scan_idx = src_idx;
        /* Get Slice Control Buffer */
        va_status = vaCreateBuffer(jd_libva_ptr->va_display, jd_libva_ptr->va_context, VASliceParameterBufferType, sizeof(VASliceParameterBufferJPEG) * dest_idx, 1, dest_scan_ctrl, &desc_buf[buf_idx]);
        if (va_status != VA_STATUS_SUCCESS) {
            ETRACE("vaCreateBuffer failed. va_status = 0x%x", va_status);
            status = DECODE_DRIVER_FAIL;
            return status;
        }
        buf_idx++;
        va_status = vaCreateBuffer(jd_libva_ptr->va_display, jd_libva_ptr->va_context, VASliceDataBufferType, bytes, 1, &jd_libva_ptr->bitstream_buf[ src_offset ], &desc_buf[buf_idx]);
        buf_idx++;
        if (va_status != VA_STATUS_SUCCESS) {
            ETRACE("vaCreateBuffer failed. va_status = 0x%x", va_status);
            status = DECODE_DRIVER_FAIL;
            return status;
        }
        va_status = vaRenderPicture( jd_libva_ptr->va_display, jd_libva_ptr->va_context, desc_buf, buf_idx);
        if (va_status != VA_STATUS_SUCCESS) {
            ETRACE("vaRenderPicture failed. va_status = 0x%x", va_status);
            status = DECODE_DRIVER_FAIL;
            return status;
        }
        buf_idx = 0;

        src_offset += bytes;
    } while (bytes_remaining);

    va_status = vaEndPicture(jd_libva_ptr->va_display, jd_libva_ptr->va_context);
    if (va_status != VA_STATUS_SUCCESS) {
        ETRACE("vaRenderPicture failed. va_status = 0x%x", va_status);
        status = DECODE_DRIVER_FAIL;
        return status;
    }

    va_status = vaSyncSurface(jd_libva_ptr->va_display, jd_libva_ptr->va_surfaces[0]);
    if (va_status != VA_STATUS_SUCCESS) {
        WTRACE("vaSyncSurface failed. va_status = 0x%x", va_status);
    }
#if 0
    uint8_t* rgb_buf;
    int32_t data_len = 0;
    uint32_t surface_width, surface_height;
    surface_width = (( ( jd_libva_ptr->image_width + 7 ) & ( ~7 )) + 15 ) & ( ~15 );
    surface_height = (( ( jd_libva_ptr->image_height + 7 ) & ( ~7 )) + 15 ) & ( ~15 );

    rgb_buf = (uint8_t*) malloc((surface_width * surface_height) << 2);
    if(rgb_buf == NULL){
        return DECODE_MEMORY_FAIL;
    }
    va_status = vaPutSurfaceBuf(jd_libva_ptr->va_display, jd_libva_ptr->va_surfaces[0], rgb_buf, &data_len, 0, 0, surface_width, surface_height, 0, 0, surface_width, surface_height, NULL, 0, 0);

    buf = rgb_buf;
// dump RGB data
    {
        FILE *pf_tmp = fopen("img_out.rgb", "wb");
        if(pf_tmp == NULL)
            ETRACE("Open file error");
        fwrite(rgb_buf, 1, surface_width * surface_height * 4, pf_tmp);
        fclose(pf_tmp);
    }
#endif
#if 0
    va_status = vaDeriveImage(jd_libva_ptr->va_display, jd_libva_ptr->va_surfaces[0], &(jd_libva_ptr->surface_image));
    if (va_status != VA_STATUS_SUCCESS) {
        ERREXIT1 (cinfo, JERR_VA_DRIVEIMAGE, va_status);
    }

    va_status = vaMapBuffer(jd_libva_ptr->va_display, jd_libva_ptr->surface_image.buf, (void **)& (jd_libva_ptr->image_buf));
    if (va_status != VA_STATUS_SUCCESS) {
        ERREXIT1 (cinfo, JERR_VA_MAPBUFFER, va_status);
    }

    va_status = vaUnmapBuffer(jd_libva_ptr->va_display, jd_libva_ptr->surface_image.buf);
    if (va_status != VA_STATUS_SUCCESS) {
        ERREXIT1(cinfo, JERR_VA_MAPBUFFER, va_status);
    }

    va_status = vaDestroyImage(jd_libva_ptr->va_display, jd_libva_ptr->surface_image.image_id);

    if (va_status != VA_STATUS_SUCCESS) {
        ERREXIT1 (cinfo, JERR_VA_MAPBUFFER, va_status);
    }
#endif
    return status;
}

Decode_Status parseBitstream(jd_libva_struct * jd_libva_ptr) {
    uint32_t component_order = 0 ;
    uint32_t dqt_ind = 0;
    uint32_t dht_ind = 0;
    uint32_t scan_ind = 0;
    boolean frame_marker_found = FALSE;

    uint8_t marker = jd_libva_ptr->JPEGParser->getNextMarker(jd_libva_ptr->JPEGParser);

    while (marker != CODE_EOI) {
        switch (marker) {
            // If the marker is an APP marker skip over the data
            case CODE_APP0:
            case CODE_APP1:
            case CODE_APP2:
            case CODE_APP3:
            case CODE_APP4:
            case CODE_APP5:
            case CODE_APP6:
            case CODE_APP7:
            case CODE_APP8:
            case CODE_APP9:
            case CODE_APP10:
            case CODE_APP11:
            case CODE_APP12:
            case CODE_APP13:
            case CODE_APP14:
            case CODE_APP15: {

                uint32_t bytes_to_burn = jd_libva_ptr->JPEGParser->readBytes(jd_libva_ptr->JPEGParser, 2) - 2;
                jd_libva_ptr->JPEGParser->burnBytes(jd_libva_ptr->JPEGParser, bytes_to_burn);
                    break;
            }
            // Store offset to DQT data to avoid parsing bitstream in user mode
            case CODE_DQT: {
                jd_libva_ptr->dqt_byte_offset[dqt_ind] = jd_libva_ptr->JPEGParser->getByteOffset(jd_libva_ptr->JPEGParser);
                dqt_ind++;
                uint32_t bytes_to_burn = jd_libva_ptr->JPEGParser->readBytes( jd_libva_ptr->JPEGParser, 2 ) - 2;
                jd_libva_ptr->JPEGParser->burnBytes( jd_libva_ptr->JPEGParser, bytes_to_burn );
                break;
            }
            // Throw exception for all SOF marker other than SOF0
            case CODE_SOF1:
            case CODE_SOF2:
            case CODE_SOF3:
            case CODE_SOF5:
            case CODE_SOF6:
            case CODE_SOF7:
            case CODE_SOF8:
            case CODE_SOF9:
            case CODE_SOF10:
            case CODE_SOF11:
            case CODE_SOF13:
            case CODE_SOF14:
            case CODE_SOF15: {
                fprintf(stderr, "ERROR: unsupport SOF\n");
                break;
            }
            // Parse component information in SOF marker
            case CODE_SOF_BASELINE: {
                frame_marker_found = TRUE;

                jd_libva_ptr->JPEGParser->burnBytes(jd_libva_ptr->JPEGParser, 2); // Throw away frame header length
                jd_libva_ptr->picture_param_buf.sample_precision = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);
                if (jd_libva_ptr->picture_param_buf.sample_precision != 8) {
                    return DECODE_PARSER_FAIL;
                }
                // Extract pic width and height
                jd_libva_ptr->picture_param_buf.picture_height = jd_libva_ptr->JPEGParser->readBytes(jd_libva_ptr->JPEGParser, 2);
                jd_libva_ptr->picture_param_buf.picture_width = jd_libva_ptr->JPEGParser->readBytes(jd_libva_ptr->JPEGParser, 2);
                jd_libva_ptr->picture_param_buf.num_components = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);

                if (jd_libva_ptr->picture_param_buf.num_components > JPEG_MAX_COMPONENTS) {
                    return DECODE_PARSER_FAIL;
                }
                uint8_t comp_ind;
                for (comp_ind = 0; comp_ind < jd_libva_ptr->picture_param_buf.num_components; comp_ind++) {
                    jd_libva_ptr->picture_param_buf.components[comp_ind].component_id = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);

                    uint8_t hv_sampling = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);
                    jd_libva_ptr->picture_param_buf.components[comp_ind].h_sampling_factor = hv_sampling >> 4;
                    jd_libva_ptr->picture_param_buf.components[comp_ind].v_sampling_factor = hv_sampling & 0xf;
                    jd_libva_ptr->picture_param_buf.components[comp_ind].quantiser_table_selector = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);
                }


                break;
            }
            // Store offset to DHT data to avoid parsing bitstream in user mode
            case CODE_DHT: {
                jd_libva_ptr->dht_byte_offset[dht_ind] = jd_libva_ptr->JPEGParser->getByteOffset(jd_libva_ptr->JPEGParser);
                dht_ind++;
                uint32_t bytes_to_burn = jd_libva_ptr->JPEGParser->readBytes(jd_libva_ptr->JPEGParser, 2) - 2;
                jd_libva_ptr->JPEGParser->burnBytes(jd_libva_ptr->JPEGParser,  bytes_to_burn );
                break;
            }
            // Parse component information in SOS marker
            case CODE_SOS: {
                jd_libva_ptr->JPEGParser->burnBytes(jd_libva_ptr->JPEGParser, 2);
                uint32_t component_in_scan = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);
                uint8_t comp_ind;

                for (comp_ind = 0; comp_ind < component_in_scan; comp_ind++) {
                    uint8_t comp_id = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);
                    uint8_t comp_data_ind;
                    for (comp_data_ind = 0; comp_data_ind < jd_libva_ptr->picture_param_buf.num_components; comp_data_ind++) {
                        if (comp_id == jd_libva_ptr->picture_param_buf.components[comp_data_ind].component_id) {
                            jd_libva_ptr->slice_param_buf[scan_ind].components[comp_ind].component_selector = comp_data_ind;
                            break;
                        }
                    }
                    uint8_t huffman_tables = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);
                    jd_libva_ptr->slice_param_buf[scan_ind].components[comp_ind].dc_table_selector = huffman_tables >> 4;
                    jd_libva_ptr->slice_param_buf[scan_ind].components[comp_ind].ac_table_selector = huffman_tables & 0xf;
                }
                uint32_t curr_byte = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser); // Ss
                if (curr_byte != 0) {
                    return DECODE_PARSER_FAIL;
                }
                curr_byte = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);  // Se
                if (curr_byte != 0x3f) {
                    return DECODE_PARSER_FAIL;
                }
                curr_byte = jd_libva_ptr->JPEGParser->readNextByte(jd_libva_ptr->JPEGParser);  // Ah, Al
                if (curr_byte != 0) {
                    return DECODE_PARSER_FAIL;
                }
                // Set slice control variables needed
                jd_libva_ptr->slice_param_buf[scan_ind].slice_data_offset = jd_libva_ptr->JPEGParser->getByteOffset(jd_libva_ptr->JPEGParser);
                jd_libva_ptr->slice_param_buf[scan_ind].num_components = component_in_scan;
                if (scan_ind) {
                    /* If there is more than one scan, the slice for all but the final scan should only run up to the beginning of the next scan */
                    jd_libva_ptr->slice_param_buf[scan_ind - 1].slice_data_size =
                        (jd_libva_ptr->slice_param_buf[scan_ind].slice_data_offset - jd_libva_ptr->slice_param_buf[scan_ind - 1].slice_data_offset );;
                    }
                    scan_ind++;
                    jd_libva_ptr->scan_ctrl_count++;   // gsDXVA2Globals.uiScanCtrlCount
                    break;
                }
            case CODE_DRI: {
                uint32_t size =  jd_libva_ptr->JPEGParser->readBytes(jd_libva_ptr->JPEGParser, 2);
                jd_libva_ptr->slice_param_buf[scan_ind].restart_interval =  jd_libva_ptr->JPEGParser->readBytes(jd_libva_ptr->JPEGParser, 2);
                jd_libva_ptr->JPEGParser->burnBytes(jd_libva_ptr->JPEGParser, (size - 4));
                break;
            }
            default:
                break;
        }

        marker = jd_libva_ptr->JPEGParser->getNextMarker(jd_libva_ptr->JPEGParser);
    }

    jd_libva_ptr->quant_tables_num = dqt_ind;
    jd_libva_ptr->huffman_tables_num = dht_ind;

    /* The slice for the last scan should run up to the end of the picture */
    jd_libva_ptr->slice_param_buf[scan_ind - 1].slice_data_size = (jd_libva_ptr->file_size - jd_libva_ptr->slice_param_buf[scan_ind - 1].slice_data_offset);

    // throw AppException if SOF0 isn't found
    if (!frame_marker_found) {
        ETRACE("EEORR: Reached end of bitstream while trying to parse headers\n");
        return DECODE_PARSER_FAIL;
    }

    parseTableData(jd_libva_ptr);

    return DECODE_SUCCESS;

}

Decode_Status parseTableData(jd_libva_struct * jd_libva_ptr) {
    Decode_Status status;
    CJPEGParse* parser = (CJPEGParse*)malloc(sizeof(CJPEGParse));
    if (parser == NULL)
        return DECODE_MEMORY_FAIL;

    parserInitialize(parser, jd_libva_ptr->bitstream_buf, jd_libva_ptr->file_size);

    // Parse Quant tables
    memset(&jd_libva_ptr->qmatrix_buf, 0, sizeof(jd_libva_ptr->qmatrix_buf));
    uint32_t dqt_ind;
    for (dqt_ind = 0; dqt_ind < jd_libva_ptr->quant_tables_num; dqt_ind++) {
        if (parser->setByteOffset(parser, jd_libva_ptr->dqt_byte_offset[dqt_ind])) {
            // uint32_t uiTableBytes = parser->readBytes( 2 ) - 2;
            uint32_t table_bytes = parser->readBytes( parser, 2 ) - 2;
            do {
                uint32_t table_info = parser->readNextByte(parser);
                table_bytes--;
                uint32_t table_length = table_bytes > 64 ? 64 : table_bytes;
                uint32_t table_precision = table_info >> 4;
                if (table_precision != 0) {
                    return DECODE_PARSER_FAIL;
                }
                uint32_t table_id = table_info & 0xf;
                if (table_id >= JPEG_MAX_QUANT_TABLES) {
                    return DECODE_PARSER_FAIL;
                }
                jd_libva_ptr->qmatrix_buf.load_quantiser_table[dqt_ind] = table_id;

                // Pull Quant table data from bitstream
                uint32_t byte_ind;
                for (byte_ind = 0; byte_ind < table_length; byte_ind++) {
                    jd_libva_ptr->qmatrix_buf.quantiser_table[table_id][byte_ind] = parser->readNextByte(parser);
                }
                table_bytes -= table_length;
            } while (table_bytes);
        }
    }

    // Parse Huffman tables
    memset(&jd_libva_ptr->hufman_table_buf, 0, sizeof(jd_libva_ptr->hufman_table_buf));
    uint32_t dht_ind;
    for (dht_ind = 0; dht_ind < jd_libva_ptr->huffman_tables_num; dht_ind++) {
        if (parser->setByteOffset(parser, jd_libva_ptr->dht_byte_offset[dht_ind])) {
            uint32_t table_bytes = parser->readBytes( parser, 2 ) - 2;
            do {
                uint32_t table_info = parser->readNextByte(parser);
                table_bytes--;
                uint32_t table_class = table_info >> 4; // Identifies whether the table is for AC or DC
                if (table_class >= TABLE_CLASS_NUM) {
                    return DECODE_PARSER_FAIL;
                }
                uint32_t table_id = table_info & 0xf;
                if (table_id >= JPEG_MAX_SETS_HUFFMAN_TABLES) {
                    return DECODE_PARSER_FAIL;
                }
                if (table_class == 0) {
                    uint8_t* bits = parser->getCurrentIndex(parser);
                    // Find out the number of entries in the table
                    uint32_t table_entries = 0;
                    uint32_t bit_ind;
                    for (bit_ind = 0; bit_ind < 16; bit_ind++) {
                        jd_libva_ptr->hufman_table_buf.huffman_table[table_id].num_dc_codes[bit_ind] = bits[bit_ind];
                        table_entries += jd_libva_ptr->hufman_table_buf.huffman_table[table_id].num_dc_codes[bit_ind];
                    }

                    // Create table of code values
                    parser->burnBytes(parser, 16);
                    table_bytes -= 16;
                    uint32_t tbl_ind;
                    for (tbl_ind = 0; tbl_ind < table_entries; tbl_ind++) {
                        jd_libva_ptr->hufman_table_buf.huffman_table[table_id].dc_values[tbl_ind] = parser->readNextByte(parser);
                        table_bytes--;
                    }

                } else { // for AC class
                    uint8_t* bits = parser->getCurrentIndex(parser);
                    // Find out the number of entries in the table
                    uint32_t table_entries = 0;
                    uint32_t bit_ind;
                    for (bit_ind = 0; bit_ind < 16; bit_ind++) {
                        jd_libva_ptr->hufman_table_buf.huffman_table[table_id].num_ac_codes[bit_ind] = bits[bit_ind];
                        table_entries += jd_libva_ptr->hufman_table_buf.huffman_table[table_id].num_ac_codes[bit_ind];
                    }

                    // Create table of code values
                    parser->burnBytes(parser, 16);
                    table_bytes -= 16;
                    uint32_t tbl_ind;
                    for (tbl_ind = 0; tbl_ind < table_entries; tbl_ind++) {
                        jd_libva_ptr->hufman_table_buf.huffman_table[table_id].ac_values[tbl_ind] = parser->readNextByte(parser);
                        table_bytes--;
                    }
                }//end of else

            } while (table_bytes);
        }
    }

    if (parser) {
        free(parser);
        parser = NULL;
    }
    return DECODE_SUCCESS;
}