/*

 * MXF SMPTE-436M VBI/ANC parsing functions

 * Copyright (c) 2025 Jacob Lifshay

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg 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 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg 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 FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#include "libavcodec/smpte_436m.h"

#include "bytestream.h"

#include "libavcodec/packet.h"

#include "libavutil/avassert.h"

#include "libavutil/error.h"

#include "libavutil/intreadwrite.h"

static int validate_smpte_436m_anc_wrapping_type(AVSmpte436mWrappingType wrapping_type)

{

    switch (wrapping_type) {

    case AV_SMPTE_436M_WRAPPING_TYPE_VANC_FRAME:

    case AV_SMPTE_436M_WRAPPING_TYPE_VANC_FIELD_1:

    case AV_SMPTE_436M_WRAPPING_TYPE_VANC_FIELD_2:

    case AV_SMPTE_436M_WRAPPING_TYPE_VANC_PROGRESSIVE_FRAME:

    case AV_SMPTE_436M_WRAPPING_TYPE_HANC_FRAME:

    case AV_SMPTE_436M_WRAPPING_TYPE_HANC_FIELD_1:

    case AV_SMPTE_436M_WRAPPING_TYPE_HANC_FIELD_2:

    case AV_SMPTE_436M_WRAPPING_TYPE_HANC_PROGRESSIVE_FRAME:

        return 0;

    default:

        return AVERROR_INVALIDDATA;

    }

}

static int validate_smpte_436m_anc_payload_sample_coding(AVSmpte436mPayloadSampleCoding payload_sample_coding)

{

    switch (payload_sample_coding) {

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA_AND_COLOR_DIFF:

        // not allowed for ANC packets

        return AVERROR_INVALIDDATA;

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA_AND_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF_WITH_PARITY_ERROR:

        return 0;

    default:

        return AVERROR_INVALIDDATA;

    }

}

int av_smpte_436m_coded_anc_validate(const AVSmpte436mCodedAnc *anc)

{

    int ret = validate_smpte_436m_anc_wrapping_type(anc->wrapping_type);

    if (ret < 0)

        return ret;

    ret = validate_smpte_436m_anc_payload_sample_coding(anc->payload_sample_coding);

    if (ret < 0)

        return ret;

    if (anc->payload_array_length > AV_SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY)

        return AVERROR_INVALIDDATA;

    ret = av_smpte_436m_coded_anc_payload_size(anc->payload_sample_coding, anc->payload_sample_count);

    if (ret < 0)

        return ret;

    if (anc->payload_array_length < ret)

        return AVERROR_INVALIDDATA;

    return 0;

}

// Based off Table 7 (page 13) of:

// https://pub.smpte.org/latest/st436/s436m-2006.pdf

#define SMPTE_436M_ANC_ENTRY_HEADER_SIZE ( \

    2   /* line_number */                  \

    + 1 /* wrapping_type */                \

    + 1 /* payload_sample_coding */        \

    + 2 /* payload_sample_count */         \

    + 4 /* payload_array_length */         \

    + 4 /* payload_array_element_size */   \

)

/**

 * Decode an ANC packet.

 * @param[in]  in   Input bytes.

 * @param[in]  size the size of in.

 * @param[out]  anc the decoded ANC packet

 * @return The number of read bytes on success, AVERROR_INVALIDDATA otherwise.

 */

static int smpte_436m_anc_decode_entry(const uint8_t *in, int size, AVSmpte436mCodedAnc *anc)

{

    // Based off Table 7 (page 13) of:

    // https://pub.smpte.org/latest/st436/s436m-2006.pdf

    if (SMPTE_436M_ANC_ENTRY_HEADER_SIZE > size)

        return AVERROR_INVALIDDATA;

    int needed_size  = SMPTE_436M_ANC_ENTRY_HEADER_SIZE;

    anc->line_number = AV_RB16(in);

    in += 2;

    anc->wrapping_type = AV_RB8(in);

    in++;

    anc->payload_sample_coding = AV_RB8(in);

    in++;

    anc->payload_sample_count = AV_RB16(in);

    in += 2;

    anc->payload_array_length = AV_RB32(in);

    in += 4;

    uint32_t payload_array_element_size = AV_RB32(in);

    in += 4;

    if (payload_array_element_size != 1)

        return AVERROR_INVALIDDATA;

    needed_size += anc->payload_array_length;

    if (needed_size > size)

        return AVERROR_INVALIDDATA;

    if (anc->payload_array_length > AV_SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY)

        return AVERROR_INVALIDDATA;

    memcpy(anc->payload, in, anc->payload_array_length);

    int ret = av_smpte_436m_coded_anc_validate(anc);

    if (ret < 0)

        return ret;

    return needed_size;

}

/**

 * Encode an ANC packet.

 * @param[in]  anc  the ANC packet to encode

 * @param[in]  size the size of out. ignored if out is NULL.

 * @param[out] out  Output bytes. Doesn't write anything if out is NULL.

 * @return the number of bytes written on success, AVERROR codes otherwise.

 *         If out is NULL, returns the number of bytes it would have written.

 */

static int smpte_436m_anc_encode_entry(uint8_t *out, int size, const AVSmpte436mCodedAnc *anc)

{

    // Based off Table 7 (page 13) of:

    // https://pub.smpte.org/latest/st436/s436m-2006.pdf

    if (anc->payload_array_length > AV_SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY)

        return AVERROR_INVALIDDATA;

    int needed_size = SMPTE_436M_ANC_ENTRY_HEADER_SIZE + (int)anc->payload_array_length;

    if (!out)

        return needed_size;

    if (needed_size > size)

        return AVERROR_BUFFER_TOO_SMALL;

    AV_WB16(out, anc->line_number);

    out += 2;

    AV_WB8(out, anc->wrapping_type);

    out++;

    AV_WB8(out, anc->payload_sample_coding);

    out++;

    AV_WB16(out, anc->payload_sample_count);

    out += 2;

    AV_WB32(out, anc->payload_array_length);

    out += 4;

    AV_WB32(out, 1); // payload_array_element_size

    out += 4;

    memcpy(out, anc->payload, anc->payload_array_length);

    return needed_size;

}

int av_smpte_436m_anc_encode(uint8_t *out, int size, int anc_packet_count, const AVSmpte436mCodedAnc *anc_packets)

{

    // Based off Table 7 (page 13) of:

    // https://pub.smpte.org/latest/st436/s436m-2006.pdf

    if (anc_packet_count < 0 || anc_packet_count >= (1L << 16) || size < 0)

        return AVERROR_INVALIDDATA;

    int needed_size = 2;

    if (out) {

        if (size < needed_size)

            return AVERROR_BUFFER_TOO_SMALL;

        AV_WB16(out, anc_packet_count);

        out += 2;

        size -= 2;

    }

    for (int i = 0; i < anc_packet_count; i++) {

        int ret = smpte_436m_anc_encode_entry(out, size, &anc_packets[i]);

        if (ret < 0)

            return ret;

        needed_size += ret;

        if (out) {

            size -= ret;

            out += ret;

        }

    }

    return needed_size;

}

int av_smpte_436m_anc_append(AVPacket *pkt, int anc_packet_count, const AVSmpte436mCodedAnc *anc_packets)

{

    int final_packet_count = 0;

    int write_start        = 2;

    if (pkt->size >= 2) {

        final_packet_count = AV_RB16(pkt->data);

        write_start        = pkt->size;

    } else if (pkt->size != 0) // if packet isn't empty

        return AVERROR_INVALIDDATA;

    if (anc_packet_count < 0 || anc_packet_count >= (1L << 16))

        return AVERROR_INVALIDDATA;

    final_packet_count += anc_packet_count;

    if (final_packet_count >= (1L << 16))

        return AVERROR_INVALIDDATA;

    int ret, additional_size = write_start - pkt->size;

    for (int i = 0; i < anc_packet_count; i++) {

        ret = smpte_436m_anc_encode_entry(NULL, 0, &anc_packets[i]);

        if (ret < 0)

            return ret;

        additional_size += ret;

    }

    ret = av_grow_packet(pkt, additional_size);

    if (ret < 0)

        return ret;

    for (int i = 0; i < anc_packet_count; i++) {

        ret = smpte_436m_anc_encode_entry(pkt->data + write_start, pkt->size - write_start, &anc_packets[i]);

        av_assert0(ret >= 0);

        write_start += ret;

    }

    AV_WB16(pkt->data, final_packet_count);

    return 0;

}

int av_smpte_436m_anc_iter_init(AVSmpte436mAncIterator *iter, const uint8_t *buf, int buf_size)

{

    // Based off Table 7 (page 13) of:

    // https://pub.smpte.org/latest/st436/s436m-2006.pdf

    if (buf_size < 2)

        return AVERROR_INVALIDDATA;

    *iter = (AVSmpte436mAncIterator){

        .anc_packets_left = AV_RB16(buf),

        .size_left        = buf_size - 2,

        .data_left        = buf + 2,

    };

    if (iter->anc_packets_left > iter->size_left)

        return AVERROR_INVALIDDATA;

    return 0;

}

int av_smpte_436m_anc_iter_next(AVSmpte436mAncIterator *iter, AVSmpte436mCodedAnc *anc)

{

    if (iter->anc_packets_left <= 0)

        return AVERROR_EOF;

    iter->anc_packets_left--;

    int ret = smpte_436m_anc_decode_entry(iter->data_left, iter->size_left, anc);

    if (ret < 0) {

        iter->anc_packets_left = 0;

        return ret;

    }

    iter->data_left += ret;

    iter->size_left -= ret;

    return 0;

}

int av_smpte_436m_coded_anc_payload_size(AVSmpte436mPayloadSampleCoding sample_coding, uint16_t sample_count)

{

    if (sample_count > AV_SMPTE_436M_CODED_ANC_SAMPLE_CAPACITY)

        return AVERROR_INVALIDDATA;

    switch (sample_coding) {

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA_AND_COLOR_DIFF:

        return AVERROR_INVALIDDATA;

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF_WITH_PARITY_ERROR:

        // "The Payload Byte Array shall be padded to achieve UInt32 alignment."

        // section 4.4 of https://pub.smpte.org/latest/st436/s436m-2006.pdf

        return (sample_count + 3) & -4;

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA_AND_COLOR_DIFF:

        // encoded with 3 10-bit samples in a UInt32.

        // "The Payload Byte Array shall be padded to achieve UInt32 alignment."

        // section 4.4 of https://pub.smpte.org/latest/st436/s436m-2006.pdf

        return 4 * ((sample_count + 2) / 3);

    default:

        return AVERROR_INVALIDDATA;

    }

}

int av_smpte_291m_anc_8bit_decode(AVSmpte291mAnc8bit            *out,

                                  AVSmpte436mPayloadSampleCoding sample_coding,

                                  uint16_t                       sample_count,

                                  const uint8_t                 *payload,

                                  void                          *log_ctx)

{

    switch (sample_coding) {

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA_AND_COLOR_DIFF:

        return AVERROR_INVALIDDATA;

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF_WITH_PARITY_ERROR:

        {

            if (sample_count < 3)

                return AVERROR_INVALIDDATA;

            out->did         = *payload++;

            out->sdid_or_dbn = *payload++;

            out->data_count  = *payload++;

            if (sample_count < out->data_count + 3)

                return AVERROR_INVALIDDATA;

            memcpy(out->payload, payload, out->data_count);

            // the checksum isn't stored in 8-bit mode, so calculate it.

            av_smpte_291m_anc_8bit_fill_checksum(out);

            return 0;

        }

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA_AND_COLOR_DIFF:

        av_log(log_ctx,

               AV_LOG_ERROR,

               "decoding an ANC packet using the 10-bit SMPTE 436M sample coding isn't implemented.\n");

        return AVERROR_PATCHWELCOME;

    default:

        return AVERROR_INVALIDDATA;

    }

}

void av_smpte_291m_anc_8bit_fill_checksum(AVSmpte291mAnc8bit *anc)

{

    uint8_t checksum = anc->did + anc->sdid_or_dbn + anc->data_count;

    for (unsigned i = 0; i < anc->data_count; i++) {

        checksum += anc->payload[i];

    }

    anc->checksum = checksum;

}

int av_smpte_291m_anc_8bit_get_sample_count(const AVSmpte291mAnc8bit      *anc,

                                            AVSmpte436mPayloadSampleCoding sample_coding,

                                            void                          *log_ctx)

{

    switch (sample_coding) {

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA_AND_COLOR_DIFF:

        return AVERROR_INVALIDDATA;

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF_WITH_PARITY_ERROR:

        // 3 for did, sdid_or_dbn, and data_count; checksum isn't stored in 8-bit modes

        return 3 + anc->data_count;

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA_AND_COLOR_DIFF:

        av_log(log_ctx,

               AV_LOG_ERROR,

               "encoding an ANC packet using the 10-bit SMPTE 436M sample coding isn't implemented.\n");

        return AVERROR_PATCHWELCOME;

    default:

        return AVERROR_INVALIDDATA;

    }

}

int av_smpte_291m_anc_8bit_encode(AVSmpte436mCodedAnc           *out,

                                  uint16_t                       line_number,

                                  AVSmpte436mWrappingType        wrapping_type,

                                  AVSmpte436mPayloadSampleCoding sample_coding,

                                  const AVSmpte291mAnc8bit      *payload,

                                  void                          *log_ctx)

{

    out->line_number           = line_number;

    out->wrapping_type         = wrapping_type;

    out->payload_sample_coding = sample_coding;

    int ret = av_smpte_291m_anc_8bit_get_sample_count(payload, sample_coding, log_ctx);

    if (ret < 0)

        return ret;

    out->payload_sample_count = ret;

    ret = av_smpte_436m_coded_anc_payload_size(sample_coding, out->payload_sample_count);

    if (ret < 0)

        return ret;

    out->payload_array_length = ret;

    switch (sample_coding) {

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA_AND_COLOR_DIFF:

        return AVERROR_INVALIDDATA;

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF_WITH_PARITY_ERROR:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF_WITH_PARITY_ERROR:

        {

            // fill trailing padding with zeros

            av_assert0(out->payload_array_length >= 4);

            memset(out->payload + out->payload_array_length - 4, 0, 4);

            out->payload[0] = payload->did;

            out->payload[1] = payload->sdid_or_dbn;

            out->payload[2] = payload->data_count;

            memcpy(out->payload + 3, payload->payload, payload->data_count);

            return 0;

        }

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_COLOR_DIFF:

    case AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA_AND_COLOR_DIFF:

        av_log(log_ctx,

               AV_LOG_ERROR,

               "encoding an ANC packet using the 10-bit SMPTE 436M sample coding isn't implemented.\n");

        return AVERROR_PATCHWELCOME;

    default:

        return AVERROR_INVALIDDATA;

    }

}

int av_smpte_291m_anc_8bit_extract_cta_708(const AVSmpte291mAnc8bit *anc, uint8_t *cc_data, void *log_ctx)

{

    if (anc->did != AV_SMPTE_291M_ANC_DID_CTA_708 || anc->sdid_or_dbn != AV_SMPTE_291M_ANC_SDID_CTA_708)

        return AVERROR(EAGAIN);

    GetByteContext gb;

    bytestream2_init(&gb, anc->payload, anc->data_count);

    // based on Caption Distribution Packet (CDP) Definition:

    // https://pub.smpte.org/latest/st334-2/st0334-2-2015.pdf

    uint16_t cdp_identifier = bytestream2_get_be16(&gb);

    if (cdp_identifier != 0x9669) { // CDPs always have this value

        av_log(log_ctx, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);

        return AVERROR_INVALIDDATA;

    }

    bytestream2_get_byte(&gb); // cdp_length

    bytestream2_get_byte(&gb); // cdp_frame_rate and reserved

    bytestream2_get_byte(&gb); // flags

    bytestream2_get_be16(&gb); // cdp_hdr_sequence_cntr

    unsigned section_id = bytestream2_get_byte(&gb);

    const unsigned TIME_CODE_SECTION_ID = 0x71;

    if (section_id == TIME_CODE_SECTION_ID) {

        bytestream2_skip(&gb, 4); // skip time code section

        section_id = bytestream2_get_byte(&gb);

    }

    const unsigned CC_DATA_SECTION_ID = 0x72;

    if (section_id == CC_DATA_SECTION_ID) {

        if (bytestream2_get_bytes_left(&gb) < 1)

            goto too_short;

        // 0x1F for lower 5 bits, upper 3 bits are marker bits

        unsigned cc_count    = bytestream2_get_byte(&gb) & 0x1F;

        unsigned data_length = cc_count * 3; // EIA-608/CTA-708 triples are 3 bytes long

        if (bytestream2_get_bytes_left(&gb) < data_length)

            goto too_short;

        if (cc_data)

            bytestream2_get_bufferu(&gb, cc_data, data_length);

        return cc_count;

    }

    return AVERROR(EAGAIN);

too_short:

    av_log(log_ctx, AV_LOG_ERROR, "not enough bytes in cdp\n");

    return AVERROR_INVALIDDATA;

}