/*!
 * COPYRIGHT (C) 2020 Emeric Grange - All Rights Reserved
 *
 * This file is part of MiniVideo.
 *
 * MiniVideo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * MiniVideo 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with MiniVideo.  If not, see <http://www.gnu.org/licenses/>.
 *
 * \file      pes.c
 * \author    Emeric Grange <emeric.grange@gmail.com>
 * \date      2012
 */

// minivideo headers
#include "pes.h"
#include "minivideo/bitstream_utils.h"
#include "minivideo/minitraces.h"

// C standard libraries
#include <cstdio>
#include <cstdlib>
#include <climits>
#include <cmath>

/* ************************************************************************** */

/*!
 * \brief Jumpy protect your parsing - PES edition.
 * \param bitstr: Our bitstream reader.
 * \param header: A pointer to a PES header structure.
 * \return SUCCESS or FAILURE if the jump could not be done.
 *
 * 'Jumpy' is in charge of checking your position into the stream after your
 * parser finish parsing a box / list / chunk / element, never leaving you
 * stranded  in the middle of nowhere with no easy way to get back on track.
 * It will check available informations to known if the current element has been
 * fully parsed, and if not perform a jump (or even a rewind) to the next known
 * element.
 */
int jumpy_pes(Bitstream_t *bitstr, PesHeader_t *header)
{
    int retcode = SUCCESS;

    // Done as a precaution, because the parsing of some boxes (like ESDS...)
    // can leave us in the middle of a byte and that will never be caught by
    // offset checks (cause they works on the assumption that we are byte aligned)
    bitstream_force_alignment(bitstr);

    // Check if we need a jump
    int64_t current_pos = bitstream_get_absolute_byte_offset(bitstr);
    if (current_pos != header->offset_end)
    {
        int64_t file_size = bitstream_get_full_size(bitstr);

        // If the offset_end is past the last byte of the file, we do not need to jump
        // The parser will pick that fact and finish up...
        if (header->offset_end >= file_size)
        {
            bitstr->bitstream_offset = file_size;
            return SUCCESS;
        }

        // Now, do we need to go forward or backward to reach our goal?
        // Then, can we move in our current buffer or do we need to reload a new one?
        if (current_pos < header->offset_end)
        {
            int64_t jump = header->offset_end - current_pos;

            if (jump < (UINT_MAX/8))
                retcode = skip_bits(bitstr, (unsigned int)(jump*8));
            else
                retcode = bitstream_goto_offset(bitstr, header->offset_end);
        }
        else
        {
            int64_t rewind = current_pos - header->offset_end;

            if (rewind > 0)
            {
                if (rewind > (UINT_MAX/8))
                    retcode = rewind_bits(bitstr, (unsigned int)(rewind*8));
                else
                    retcode = bitstream_goto_offset(bitstr, header->offset_end);
            }
        }
    }

    return retcode;
}

/* ************************************************************************** */

/*!
 * \brief Parse PES packet header, common to all PES packet types.
 * \param *bitstr: The bitstream to use.
 * \param *header: A pointer to a PES header structure.
 * \return 1 if succeed, 0 otherwise.
 *
 * From 'ISO/IEC 13818-1' specification:
 * 2.4.3.6 PES packet.
 * Table 2-17 – PES packet.
 */
int parse_pes_header(Bitstream_t *bitstr, PesHeader_t *header)
{
    TRACE_2(MPS, "> parse_pes_header()");

    header->offset_start    = bitstream_get_absolute_byte_offset(bitstr);

    header->start_code      = read_bits(bitstr, 32);
    header->stream_id       = header->start_code & 0x000000FF;
    header->payload_length  = read_bits(bitstr, 16);
    header->packet_length   = header->payload_length + 6;

    header->offset_end      = header->offset_start + header->packet_length;

    return SUCCESS;
}

/* ************************************************************************** */

/*!
 * \brief Parse PES packet.
 * \param *bitstr: The bitstream to use.
 * \param *header: A pointer to a PES header structure.
 * \param *packet: A pointer to a PES packet structure.
 * \return 1 if succeed, 0 otherwise.
 *
 * From 'ISO/IEC 13818-1' specification:
 * 2.4.3.6 PES packet.
 * Table 2-17 – PES packet.
 *
 * Parse both MPEG-1 (ISO/IEC 11172-1) and MPEG-2 (ISO/IEC 13818-1) PES packets.
 */
int parse_pes(Bitstream_t *bitstr, PesHeader_t *header, PesPacket_t *packet)
{
    TRACE_2(MPS, "> parse_pes()");
    int retcode = SUCCESS;

    TRACE_INFO(MPS, "parse_pes() 0x%X @ %lli",
               header->start_code, bitstream_get_absolute_byte_offset(bitstr));

    // "regular" PES packet?
    if ((header->stream_id != SID_PROGRAM_STREAM_MAP) &&
        (header->stream_id != SID_PADDING) &&
        (header->stream_id != SID_PRIVATE_STREAM_2) &&
        (header->stream_id != SID_ECM_STREAM) &&
        (header->stream_id != SID_EMM_STREAM) &&
        (header->stream_id != SID_PROGRAM_STREAM_DIRECTORY) &&
        (header->stream_id != SID_DSMCC_STREAM) &&
        (header->stream_id != SID_2221E))
    {
        unsigned checkversion = next_bits(bitstr, 2);

        // Parse MPEG-2 PES header
        if ((checkversion & 0x02) == 0x02)
        {
            packet->mpeg_version = 2;

            if (read_bits(bitstr, 2) != 2)
            {
                TRACE_ERROR(MPS, "wrong 'marker_bits'");
                return FAILURE;
            }

            packet->PES_scrambling_control = read_bits(bitstr, 2);
            packet->PES_priority = read_bit(bitstr);
            packet->data_alignment_indicator = read_bit(bitstr);
            packet->copyright = read_bit(bitstr);
            packet->original_or_copy = read_bit(bitstr);
            packet->PTS_DTS_flag = read_bits(bitstr, 2);
            packet->ESCR_flag = read_bit(bitstr);
            packet->ES_rate_flag = read_bit(bitstr);
            packet->DSM_trick_mode_flag = read_bit(bitstr);
            packet->additional_copy_info_flag = read_bit(bitstr);
            packet->PES_CRC_flag = read_bit(bitstr);
            packet->PES_extension_flag = read_bit(bitstr);
            packet->PES_header_data_length = read_bits(bitstr, 8);

            if (packet->PTS_DTS_flag == 2)
            {
                if (read_bits(bitstr, 4) != 2)
                {
                    TRACE_ERROR(MPS, "wrong 'marker_bit'");
                    return FAILURE;
                }
                packet->PTS = read_bits(bitstr, 3) << 30;
                MARKER_BIT
                packet->PTS += read_bits(bitstr, 15) << 15;
                MARKER_BIT
                packet->PTS += read_bits(bitstr, 15);
                MARKER_BIT
            }
            else if (packet->PTS_DTS_flag == 3)
            {
                if (read_bits(bitstr, 4) != 3)
                {
                    TRACE_ERROR(MPS, "wrong 'marker_bit'");
                    return FAILURE;
                }
                packet->PTS = read_bits(bitstr, 3) << 30;
                MARKER_BIT
                packet->PTS += read_bits(bitstr, 15) << 15;
                MARKER_BIT
                packet->PTS += read_bits(bitstr, 15);
                MARKER_BIT
                if (read_bits(bitstr, 4) != 1)
                {
                    TRACE_ERROR(MPS, "wrong 'marker_bit'");
                    return FAILURE;
                }
                packet->DTS = read_bits(bitstr, 3) << 30;
                MARKER_BIT
                packet->DTS += read_bits(bitstr, 15) << 15;
                MARKER_BIT
                packet->DTS += read_bits(bitstr, 15);
                MARKER_BIT
            }

            if (packet->ESCR_flag == 1)
            {
                packet->ESCR_base = read_bits(bitstr, 3) << 30;
                MARKER_BIT
                packet->ESCR_base += read_bits(bitstr, 15) << 15;
                MARKER_BIT
                packet->ESCR_base += read_bits(bitstr, 15);
                MARKER_BIT
                packet->ESCR_extension = read_bits(bitstr, 9);
                MARKER_BIT
            }

            if (packet->ES_rate_flag == 1)
            {
                MARKER_BIT
                packet->ES_rate = read_bits(bitstr, 22);
                MARKER_BIT
            }

            if (packet->DSM_trick_mode_flag == 1)
            {
                packet->trick_mode_control = read_bits(bitstr, 3);

                if (packet->trick_mode_control == TM_FAST_FORWARD)
                {
                    packet->field_id = read_bits(bitstr, 2);
                    packet->intra_slice_refresh = read_bit(bitstr);
                    packet->frequency_truncation = read_bits(bitstr, 2);
                }
                else if (packet->trick_mode_control == TM_SLOW_MOTION)
                {
                    packet->rep_cntrl = read_bits(bitstr, 5);
                }
                else if (packet->trick_mode_control == TM_FREEZE_FRAME)
                {
                    packet->field_id = read_bits(bitstr, 2);
                    /*int reserved =*/ read_bits(bitstr, 3);
                }
                else if (packet->trick_mode_control == TM_FAST_REVERSE)
                {
                    packet->field_id = read_bits(bitstr, 2);
                    packet->intra_slice_refresh = read_bit(bitstr);
                    packet->frequency_truncation = read_bits(bitstr, 2);
                }
                else if (packet->trick_mode_control == TM_SLOW_REVERSE)
                {
                    packet->rep_cntrl = read_bits(bitstr, 5);
                }
                else
                {
                    /*int reserved =*/ read_bits(bitstr, 5);
                }
            }

            if (packet->additional_copy_info_flag == 1)
            {
                MARKER_BIT
                packet->additional_copy_info = read_bits(bitstr, 7);
            }

            if (packet->PES_CRC_flag == 1)
            {
                packet->previous_PES_packet_CRC = read_bits(bitstr, 16);
            }

            if (packet->PES_extension_flag == 1)
            {
                packet->PES_private_data_flag = read_bit(bitstr);
                packet->pack_header_field_flag = read_bit(bitstr);
                packet->program_packet_sequence_counter_flag = read_bit(bitstr);
                packet->PSTD_buffer_flag = read_bit(bitstr);
                /*int reserved =*/ read_bits(bitstr, 3);
                packet->PES_extension_flag_2 = read_bit(bitstr);

                if (packet->PES_private_data_flag == 1)
                {
                    for (int i = 0; i < 16; i++)
                    {
                        packet->PES_private_data[i] = read_bits(bitstr, 8);
                    }
                }

                if (packet->pack_header_field_flag == 1)
                {
                    packet->pack_field_length = read_bits(bitstr, 8);
                    // TODO
                    //parse_pack_header(bitstr, wtf);
                }

                if (packet->program_packet_sequence_counter_flag == 1)
                {
                    MARKER_BIT
                    packet->program_packet_sequence_counter = read_bits(bitstr, 7);
                    MARKER_BIT
                    packet->MPEG1_MPEG2_identifier = read_bit(bitstr);
                    packet->original_stuff_length = read_bits(bitstr, 6);
                }

                if (packet->PSTD_buffer_flag == 1)
                {
                    if (read_bits(bitstr, 2) != 1)
                    {
                        TRACE_ERROR(MPS, "wrong 'marker_bit'");
                        return FAILURE;
                    }
                    packet->PSTD_buffer_scale = read_bit(bitstr);
                    packet->PSTD_buffer_size = read_bits(bitstr, 13);
                }

                if (packet->PES_extension_flag_2 == 1)
                {
                    MARKER_BIT
                    packet->PES_extension_field_length = read_bits(bitstr, 7);
                    for (int i = 0; i < packet->PES_extension_field_length; i++)
                    {
                        /*int reserved =*/ read_bits(bitstr, 8);
                    }
                }
            }
        }
        else // Parse MPEG-1 PES header
        {
            packet->mpeg_version = 1;
            packet->PES_header_data_length = 0; // We will emulate this field

            // MPEG-1: up to 16 stuffing bytes here (optional)
            while (next_bits(bitstr, 8) == 0xFF)
            {
                skip_bits(bitstr, 8);
                packet->PES_header_data_length++;
            }

            // Optional
            if (next_bits(bitstr, 2) == 1)
            {
                skip_bits(bitstr, 2);
                packet->PES_header_data_length += 2;

                packet->PSTD_buffer_scale = read_bit(bitstr);
                packet->PSTD_buffer_size = read_bits(bitstr, 13);
            }

            if (next_bits(bitstr, 8) == 0x0F)
            {
                skip_bits(bitstr, 8);
                packet->PES_header_data_length++;
            }
            else
            {
                if (next_bits(bitstr, 2) != 0)
                {
                    TRACE_ERROR(MPS, "wrong 'marker_bit' PESv1");
                    return FAILURE;
                }

                packet->PTS_DTS_flag = read_bits(bitstr, 2);

                if (packet->PTS_DTS_flag == 2)
                {
                    packet->PES_header_data_length += 5;

                    packet->PTS = read_bits(bitstr, 3) << 30;
                    MARKER_BIT
                    packet->PTS += read_bits(bitstr, 15) << 15;
                    MARKER_BIT
                    packet->PTS += read_bits(bitstr, 15);
                    MARKER_BIT
                }
                else if (packet->PTS_DTS_flag == 3)
                {
                    packet->PES_header_data_length += 10;

                    packet->PTS = read_bits(bitstr, 3) << 30;
                    MARKER_BIT
                    packet->PTS += read_bits(bitstr, 15) << 15;
                    MARKER_BIT
                    packet->PTS += read_bits(bitstr, 15);
                    MARKER_BIT

                    if (read_bits(bitstr, 4) != 1)
                    {
                        TRACE_ERROR(MPS, "wrong 'marker_bit' (PTS_DTS_flag==3)");
                        return FAILURE;
                    }

                    packet->DTS = read_bits(bitstr, 3) << 30;
                    MARKER_BIT
                    packet->DTS += read_bits(bitstr, 15) << 15;
                    MARKER_BIT
                    packet->DTS += read_bits(bitstr, 15);
                    MARKER_BIT
                }
                else
                {
                    packet->PES_header_data_length++;

                    if (read_bits(bitstr, 4) == 0x0F)
                    {
                        TRACE_ERROR(MPS, "wrong 'marker_bit' (PTS_DTS_flag==0)");
                        return FAILURE;
                    }
                }
            }
        }

        // Skip packet data
        //retcode = skip_pes_data(bitstr, packet);
/*
        // TODO
        int i = 0, N1 = 0, N2 = 0;

        for (i = 0; i < N1; i++)
        {
            if (read_bits(bitstr, 8) != 0xFF)
            {
                TRACE_ERROR(MPS, BLD_GREEN "wrong 'stuffing_byte'" CLR_RESET);
                return FAILURE;
            }
        }

        for (i = 0; i < N2; i++)
        {
            uint8_t PES_packet_data_byte = read_bits(bitstr, 8);
        }
*/
    }

    return retcode;
}

/* ************************************************************************** */

void print_pes(PesHeader_t *header, PesPacket_t *packet)
{
    TRACE_INFO(MPS, BLD_GREEN "print_pes()" CLR_RESET);

    // Header
    TRACE_INFO(MPS, " packet_start_offset   = %lli", header->offset_start);
    TRACE_INFO(MPS, " packet_end_offset     = %lli", header->offset_end);

    TRACE_INFO(MPS, " packet_start_code     = 0x%06X", header->start_code);
    TRACE_INFO(MPS, " stream_id             = 0x%02X", header->start_code);
    TRACE_INFO(MPS, " PES_packet_length     = %i", header->payload_length);

    // "regular" PES packet?
    if ((header->stream_id != SID_PROGRAM_STREAM_MAP) &&
        (header->stream_id != SID_PADDING) &&
        (header->stream_id != SID_PRIVATE_STREAM_2) &&
        (header->stream_id != SID_ECM_STREAM) &&
        (header->stream_id != SID_EMM_STREAM) &&
        (header->stream_id != SID_PROGRAM_STREAM_DIRECTORY) &&
        (header->stream_id != SID_DSMCC_STREAM) &&
        (header->stream_id != SID_2221E))
    {
        TRACE_1(MPS, " PES_scrambling_control   = %i", packet->PES_scrambling_control);
        TRACE_1(MPS, " PES_priority             = %i", packet->PES_priority);
        TRACE_1(MPS, " data_alignment_indicator = %i", packet->data_alignment_indicator);
        TRACE_1(MPS, " copyright                = %i", packet->copyright);
        TRACE_1(MPS, " original_or_copy         = %i", packet->original_or_copy);
        TRACE_1(MPS, " PTS_DTS_flag             = %i", packet->PTS_DTS_flag);
        TRACE_1(MPS, " ESCR_flag                = %i", packet->ESCR_flag);
        TRACE_1(MPS, " ES_rate_flag             = %i", packet->ES_rate_flag);
        TRACE_1(MPS, " DSM_trick_mode_flag      = %i", packet->DSM_trick_mode_flag);
        TRACE_1(MPS, " additional_copy_info_flag= %i", packet->additional_copy_info_flag);
        TRACE_1(MPS, " PES_CRC_flag             = %i", packet->PES_CRC_flag);
        TRACE_1(MPS, " PES_extension_flag       = %i", packet->PES_extension_flag);
        TRACE_1(MPS, " PES_header_data_length   = %i", packet->PES_header_data_length);

        if (packet->PTS_DTS_flag == 2)
        {
            TRACE_1(MPS, " PTS      = %i", packet->PTS);
        }
        else if (packet->PTS_DTS_flag == 3)
        {
            TRACE_1(MPS, " PTS      = %i", packet->PTS);
            TRACE_1(MPS, " DTS      = %i", packet->DTS);
        }

        if (packet->ESCR_flag == 1)
        {
            TRACE_1(MPS, " ESCR_base        = %i", packet->ESCR_base);
            TRACE_1(MPS, " ESCR_extension   = %i", packet->ESCR_extension);
        }

        if (packet->ES_rate_flag == 1)
        {
            TRACE_1(MPS, " ES_rate  = %i", packet->ES_rate);
        }

        if (packet->DSM_trick_mode_flag == 1)
        {
            TRACE_1(MPS, " trick_mode_control= %i", packet->trick_mode_control);

            if (packet->trick_mode_control == TM_FAST_FORWARD)
            {
                TRACE_1(MPS, " field_id             = %i", packet->field_id);
                TRACE_1(MPS, " intra_slice_refresh  = %i", packet->intra_slice_refresh);
                TRACE_1(MPS, " frequency_truncation = %i", packet->frequency_truncation);
            }
            else if (packet->trick_mode_control == TM_SLOW_MOTION)
            {
                TRACE_1(MPS, " rep_cntrl= %i", packet->rep_cntrl);
            }
            else if (packet->trick_mode_control == TM_FREEZE_FRAME)
            {
                TRACE_1(MPS, " field_id= %i", packet->field_id);
            }
            else if (packet->trick_mode_control == TM_FAST_REVERSE)
            {
                TRACE_1(MPS, " field_id             = %i", packet->field_id);
                TRACE_1(MPS, " intra_slice_refresh  = %i", packet->intra_slice_refresh);
                TRACE_1(MPS, " frequency_truncation = %i", packet->frequency_truncation);
            }
            else if (packet->trick_mode_control == TM_SLOW_REVERSE)
            {
                TRACE_1(MPS, " rep_cntrl= %i", packet->rep_cntrl);
            }
        }

        if (packet->additional_copy_info_flag == 1)
        {
            TRACE_1(MPS, " additional_copy_info= %i", packet->additional_copy_info);
        }

        if (packet->PES_CRC_flag == 1)
        {
            TRACE_1(MPS, " previous_PES_packet_CRC= %i", packet->previous_PES_packet_CRC);
        }

        if (packet->PES_extension_flag == 1)
        {
            TRACE_1(MPS, " PES_private_data_flag    = %i", packet->PES_private_data_flag);
            TRACE_1(MPS, " pack_header_field_flag   = %i", packet->pack_header_field_flag);
            TRACE_1(MPS, " program_packet_sequence_counter_flag= %i", packet->program_packet_sequence_counter_flag);
            TRACE_1(MPS, " PSTD_buffer_flag         = %i", packet->PSTD_buffer_flag);
            TRACE_1(MPS, " PES_extension_flag_2     = %i", packet->PES_extension_flag_2);

            if (packet->PES_private_data_flag == 1)
            {
                int i = 0;
                for (i = 0; i < 16; i++)
                {
                    TRACE_1(MPS, " PES_private_data[%i]= %i", i, packet->PES_private_data[i]);
                }
            }

            if (packet->pack_header_field_flag == 1)
            {
                TRACE_1(MPS, " pack_field_length= %i", packet->pack_field_length);
                // TODO
                //parse_pack_header(bitstr, wtf);
            }

            if (packet->program_packet_sequence_counter_flag == 1)
            {
                TRACE_1(MPS, " program_packet_sequence_counter  = %i", packet->program_packet_sequence_counter);
                TRACE_1(MPS, " MPEG1_MPEG2_identifier           = %i", packet->MPEG1_MPEG2_identifier);
                TRACE_1(MPS, " original_stuff_length            = %i", packet->original_stuff_length);
            }

            if (packet->PSTD_buffer_flag == 1)
            {
                TRACE_1(MPS, " PSTD_buffer_scale= %i", packet->PSTD_buffer_scale);
                TRACE_1(MPS, " PSTD_buffer_size = %i", packet->PSTD_buffer_size);
            }

            if (packet->PES_extension_flag_2 == 1)
            {
                TRACE_1(MPS, " PES_extension_field_length= %i", packet->PES_extension_field_length);
                for (int i = 0; i < packet->PES_extension_field_length; i++)
                {
                    TRACE_1(MPS, " reserved= xx");
                }
            }
        }
    }
}

/* ************************************************************************** */

/*!
 * \brief parse_pes_padding
 * \param bitstr: Our bitstream reader.
 * \param header
 * \param packet
 * \return 1 if succeed, 0 otherwise.
 */
int parse_pes_padding(Bitstream_t *bitstr, PesHeader_t *header, PesPacket_t *packet)
{
    TRACE_INFO(MPS, BLD_GREEN "  parse_pes_padding()" CLR_RESET);
    int retcode = SUCCESS;

    if (header->payload_length != 0)
    {
        skip_bits(bitstr, header->payload_length * 8);
        TRACE_INFO(MPS, "  > skip_padding_packet() >> %i bytes", header->payload_length);
        retcode = SUCCESS;
    }
    else
    {
        while (read_bits(bitstr, 8) == 0xFF)
        {
            // Manually skipping the padding bytes
        }
    }

    return retcode;
}

/* ************************************************************************** */

/*!
 * \brief Parse the 'body' of a PES packet containing audio data.
 * \param bitstr: Our bitstream reader.
 * \param header
 * \param packet
 * \param map
 * \return
 */
//int parse_pes_a(Bitstream_t *bitstr, PesHeader_t *header, PesPacket_t *packet,
//                MediaStream_t *map)
//{
//    TRACE_2(MPS, "> parse_pes_a()");
//    int retcode = SUCCESS;
//
//    if (header->stream_id == SID_PRIVATE_STREAM_1)
//    {
//        // Look for a known "non-MPEG" start code
//        uint32_t startcode = read_bits(bitstr, 32);
//
//        if ((startcode & 0xFF000000) == 0x80000000)
//        {
//            map->stream_codec = CODEC_AC3;
//
//            //pc_uint16 crc1 = (read & 0x0000FFFF);
//            uint8_t read = read_bits(bitstr, 8);
//            uint8_t fscod = (read & 0xC0) >> 6;
//            uint8_t frmsizcod = (read & 0x3F);
//
//            switch (fscod)
//            {
//            case 0:
//                map->sampling_rate = 48000.0;
//                break;
//            case 1:
//                map->sampling_rate = 44100.0;
//                break;
//            case 2:
//                map->sampling_rate = 32000.0;
//                break;
//            default:
//                TRACE_WARNING(MPS, "Unsupported AC3 fscod %u", fscod);
//                retcode = FAILURE;
//                break;
//            }
//
//            switch (frmsizcod)
//            {
//            case 0:
//            case 1:
//                map->bitrate_avg = 32;
//                break;
//            case 2:
//            case 3:
//                map->bitrate_avg = 40;
//                break;
//            case 4:
//            case 5:
//                map->bitrate_avg = 48;
//                break;
//            case 6:
//            case 7:
//                map->bitrate_avg = 56;
//                break;
//            case 8:
//            case 9:
//                map->bitrate_avg = 64;
//                break;
//            case 10:
//            case 11:
//                map->bitrate_avg = 80;
//                break;
//            case 12:
//            case 13:
//                map->bitrate_avg = 96;
//                break;
//            case 14:
//            case 15:
//                map->bitrate_avg = 112;
//                break;
//            case 16:
//            case 17:
//                map->bitrate_avg = 128;
//                break;
//            case 18:
//            case 19:
//                map->bitrate_avg = 160;
//                break;
//            case 20:
//            case 21:
//                map->bitrate_avg = 192;
//                break;
//            case 22:
//            case 23:
//                map->bitrate_avg = 224;
//                break;
//            case 24:
//            case 25:
//                map->bitrate_avg = 256;
//                break;
//            case 26:
//            case 27:
//                map->bitrate_avg = 320;
//                break;
//            case 28:
//            case 29:
//                map->bitrate_avg = 384;
//                break;
//            case 30:
//            case 31:
//                map->bitrate_avg = 448;
//                break;
//            case 32:
//            case 33:
//                map->bitrate_avg = 512;
//                break;
//            case 34:
//            case 35:
//                map->bitrate_avg = 576;
//                break;
//            case 36:
//            case 37:
//                map->bitrate_avg = 640;
//                break;
//            default:
//                TRACE_WARNING(MPS, "Unsupported AC3 frmsizcod %u", frmsizcod);
//                retcode = FAILURE;
//                break;
//            }
//        }
//        else if ((startcode == 0x7FFE8001) ||
//                 (startcode == 0x64582025))
//        {
//            map->stream_codec = CODEC_DTS;
//
//            // 28 first bits are ignored
//            uint32_t read = read_bits(bitstr, 16);
//            read = read_bits(bitstr, 32);
//
//            //uint32_t FSIZE = 0; // Might be necessary to skip the frame and go read the extension
//            //uint32_t AMODE = (read & 0x000FC000) >> 18;
//            uint32_t SFREQ = (read & 0x00003C00) >> 10;
//            uint32_t RATE  = (read & 0x000003E0) >> 5;
//
//            switch (SFREQ)
//            {
//            case 1:
//                map->sampling_rate = 8000;
//                break;
//            case 2:
//                map->sampling_rate = 16000;
//                break;
//            case 3:
//                map->sampling_rate = 32000;
//                break;
//            case 6:
//                map->sampling_rate = 11025;
//                break;
//            case 7:
//                map->sampling_rate = 22050;
//                break;
//            case 8:
//                map->sampling_rate = 44100;
//                break;
//            case 11:
//                map->sampling_rate = 12000;
//                break;
//            case 12:
//                map->sampling_rate = 24000;
//                break;
//            case 13:
//                map->sampling_rate = 48000;
//                break;
//            default:
//                TRACE_WARNING(MPS, "Unsupported DTS SFREQ %u", SFREQ);
//                retcode = FAILURE;
//                break;
//            }
//
//            switch (RATE)
//            {
//            case 0:
//                map->bitrate_avg = 32000;
//                break;
//            case 1:
//                map->bitrate_avg = 56000;
//                break;
//            case 2:
//                map->bitrate_avg = 64000;
//                break;
//            case 3:
//                map->bitrate_avg = 96000;
//                break;
//            case 4:
//                map->bitrate_avg = 112000;
//                break;
//            case 5:
//                map->bitrate_avg = 128000;
//                break;
//            case 6:
//                map->bitrate_avg = 192000;
//                break;
//            case 7:
//                map->bitrate_avg = 224000;
//                break;
//            case 8:
//                map->bitrate_avg = 256000;
//                break;
//            case 9:
//                map->bitrate_avg = 320000;
//                break;
//            case 10:
//                map->bitrate_avg = 384000;
//                break;
//            case 11:
//                map->bitrate_avg = 448000;
//                break;
//            case 12:
//                map->bitrate_avg = 512000;
//                break;
//            case 13:
//                map->bitrate_avg = 576000;
//                break;
//            case 14:
//                map->bitrate_avg = 640000;
//                break;
//            case 15:
//                map->bitrate_avg = 768000;
//                break;
//            case 16:
//                map->bitrate_avg = 960000;
//                break;
//            case 17:
//                map->bitrate_avg = 1024000;
//                break;
//            case 18:
//                map->bitrate_avg = 1152000;
//                break;
//            case 19:
//                map->bitrate_avg = 1280000;
//                break;
//            case 20:
//                map->bitrate_avg = 1344000;
//                break;
//            case 21:
//                map->bitrate_avg = 1408000;
//                break;
//            case 22:
//                map->bitrate_avg = 1411000;
//                break;
//            case 23:
//                map->bitrate_avg = 1472000;
//                break;
//            case 24:
//                map->bitrate_avg = 1536000;
//                break;
//            case 29:
//                map->bitrate_avg = 2048000; // Speficifation says "open"
//                break;
//            default:
//                TRACE_WARNING(MPS, "Unsupported DTS RATE %u", RATE);
//                retcode = FAILURE;
//                break;
//            }
//        }
//        else // audio codec in private stream could also be : LPCM, AAC, ... ?
//        {
//            TRACE_WARNING(MPS, "Unknown audio codec (0x%08X) inside audio private stream", startcode);
//            retcode = FAILURE;
//        }
//    }
//    else
//    {
//        // Look for a known MP3 start code
//        uint16_t read = read_bits(bitstr, 16);
//
//        if ((read & 0xFFF0) == 0xFFF0)
//        {
//            uint16_t audio_version_id = (read & 0x000C) >> 2;
//            uint16_t layer_index = (read & 0x0003);
//
//            read = read_bits(bitstr, 8);
//            uint16_t bitrate_index = (read & 0x0078) >> 3;
//            uint16_t samplingrate_index = (read & 0x0006) >> 1;
//
//            uint32_t _mpeg_version = 0;
//            uint32_t _mpeg_layer   = 0;
//
//            switch (audio_version_id)
//            {
//            case 0x00:
//                _mpeg_version = 3; // MPEG-2.5
//                break;
//
//            case 0x01:
//            case 0x02:
//                _mpeg_version = 2; // MPEG-2
//                break;
//
//            case 0x03:
//                _mpeg_version = 1; // MPEG-1
//                break;
//            }
//
//            switch (layer_index)
//            {
//            case 0x03:
//                _mpeg_layer  = 1; // Layer 1
//                map->stream_codec = CODEC_MPEG_L1;
//                break;
//
//            case 0x02:
//                _mpeg_layer  = 2; // Layer 2
//                map->stream_codec = CODEC_MPEG_L2;
//                break;
//
//            default:
//            case 0x01:
//            case 0x00: // reserved
//                _mpeg_layer  = 3; // Layer 3
//                map->stream_codec = CODEC_MPEG_L3;
//                break;
//            }
//
//            //map->bitrate = bitrate_index_table[_mpeg_version - 1][_mpeg_layer - 1][bitrate_index];
//            //map->sampling_rate = samplingrate_index_table[_mpeg_version - 1][samplingrate_index];
//            //_mpeg_sampleperframe = sampleperframe_table[_mpeg_version - 1][_mpeg_layer - 1];
//        }
//        else
//        {
//            TRACE_WARNING(MPS, "Unknown ES type (0x%04X) inside PES audio packet (id: 0x%02X)",
//                          read, header->stream_id);
//            retcode = FAILURE;
//        }
//    }
//
//    return retcode;
//}
//
///* ************************************************************************** */
//
///*!
// * \brief Parse the 'body' of a PES packet containing video data.
// * \param bitstr: Our bitstream reader.
// * \param header
// * \param packet
// * \param map
// * \return
// */
//int parse_pes_v(Bitstream_t *bitstr, PesHeader_t *header, PesPacket_t *packet,
//                MediaStream_t *map)
//{
//    TRACE_2(MPS, "> parse_pes_v()");
//    int retcode = SUCCESS;
//
//    // Avoid trying to get infos from a splitted video sample
//    if (packet->PTS)
//    {
//        TRACE_2(MPS, "Trying get_video_infos() @ ");
//
//        TRACE_INFO(MPS, "parse_pes_v() 0x%X @ %lli",
//                   header->start_code, bitstream_get_absolute_byte_offset(bitstr));
//
//        // Look for a sequence header start code
//        uint32_t start_code = read_bits(bitstr, 32);
//
//        // MPEG-1/2
//        if (start_code == 0x000001B3)
//        {
//            uint32_t sizes = read_bits(bitstr, 32);
//            uint32_t aspect_ratio_index = (sizes & 0x000000F0) >> 4;
//            uint32_t framerate_index    = (sizes & 0x0000000F);
//
//            map->color_matrix = COLOR_SPC_BT709;
//            map->width  = (sizes & 0xFFF00000) >> 20;
//            map->height = (sizes & 0x000FFF00) >> 8;
//
//            uint32_t _mpeg_version = 2;
//
//            if (_mpeg_version == 1)
//            {
//                map->stream_codec = CODEC_MPEG1;
//
//                switch (aspect_ratio_index)
//                {
//                case 1:
//                    map->display_aspect_ratio = 1.0;
//                    break;
//                case 8:
//                case 12:
//                    map->display_aspect_ratio = (4.0 / 3.0);
//                    break;
//                case 3:
//                case 6:
//                    map->display_aspect_ratio = (16.0 / 9.0);
//                    break;
//                default:
//                    TRACE_WARNING(MPS, "Unsupported MPEG-1 aspect_ratio_index %u", aspect_ratio_index);
//                    retcode = FAILURE;
//                    break;
//                }
//            }
//            else // if (_mpeg_version == 2)
//            {
//                map->stream_codec = CODEC_MPEG2;
//
//                switch (aspect_ratio_index)
//                {
//                case 1:
//                    map->video_aspect_ratio = 1.0;
//                    break;
//                case 2:
//                    map->video_aspect_ratio = (4.0 / 3.0);
//                    break;
//                case 3:
//                    map->video_aspect_ratio = (16.0 / 9.0);
//                    break;
//                case 4:
//                    map->video_aspect_ratio = (2.21 / 1.0);
//                    break;
//                default:
//                    TRACE_WARNING(MPS, "Unsupported MPEG-2 aspect_ratio_index %u", aspect_ratio_index);
//                    retcode = FAILURE;
//                    break;
//                }
//            }
//
//            switch (framerate_index)
//            {
//            case 1:
//                map->framerate = 23.976;
//                map->framerate_num = 24000;
//                map->framerate_base = 1001;
//                break;
//            case 2:
//                map->framerate = 24.0;
//                map->framerate_num = 24;
//                map->framerate_base = 1;
//                break;
//            case 3:
//                map->framerate = 25.0;
//                map->framerate_num = 25;
//                map->framerate_base = 1;
//                break;
//            case 4:
//                map->framerate = 29.970;
//                map->framerate_num = 30000;
//                map->framerate_base = 1001;
//                break;
//            case 5:
//                map->framerate = 30.0;
//                map->framerate_num = 30;
//                map->framerate_base = 1;
//                break;
//            case 6:
//                map->framerate = 50.0;
//                map->framerate_num = 50;
//                map->framerate_base = 1;
//                break;
//            case 7:
//                map->framerate = 59.940;
//                map->framerate_num = 60000;
//                map->framerate_base = 1001;
//                break;
//            case 8:
//                map->framerate = 60.0;
//                map->framerate_num = 60;
//                map->framerate_base = 1;
//                break;
//            default:
//                TRACE_WARNING(MPS, "Unsupported MPEG-1/2 framerate_index %u", framerate_index);
//                retcode = FAILURE;
//                break;
//            }
//        }
//        else
//        {
//            TRACE_WARNING(MPS, "Unknown ES type (0x%08X) inside PES video packet (id: 0x%02X)",
//                          start_code, header->stream_id);
//            retcode = FAILURE;
//        }
//    }
//
//    return retcode;
//}

/* ************************************************************************** */