1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
|
/*
* 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
*/
#ifndef AVCODEC_SMPTE_436M_H
#define AVCODEC_SMPTE_436M_H
#include <stdint.h>
/**
* Iterator over the ANC packets in a single AV_CODEC_ID_SMPTE_436M_ANC AVPacket's data
*/
typedef struct AVSmpte436mAncIterator {
uint16_t anc_packets_left;
int size_left;
const uint8_t *data_left;
} AVSmpte436mAncIterator;
/**
* Wrapping Type from Table 7 (page 13) of:
* https://pub.smpte.org/latest/st436/s436m-2006.pdf
*/
typedef enum AVSmpte436mWrappingType
{
AV_SMPTE_436M_WRAPPING_TYPE_VANC_FRAME = 1,
AV_SMPTE_436M_WRAPPING_TYPE_VANC_FIELD_1 = 2,
AV_SMPTE_436M_WRAPPING_TYPE_VANC_FIELD_2 = 3,
AV_SMPTE_436M_WRAPPING_TYPE_VANC_PROGRESSIVE_FRAME = 4,
AV_SMPTE_436M_WRAPPING_TYPE_HANC_FRAME = 0x11,
AV_SMPTE_436M_WRAPPING_TYPE_HANC_FIELD_1 = 0x12,
AV_SMPTE_436M_WRAPPING_TYPE_HANC_FIELD_2 = 0x13,
AV_SMPTE_436M_WRAPPING_TYPE_HANC_PROGRESSIVE_FRAME = 0x14,
/** not a real wrapping type, just here to guarantee the enum is big enough */
AV_SMPTE_436M_WRAPPING_TYPE_MAX = 0xFF,
} AVSmpte436mWrappingType;
/**
* Payload Sample Coding from Table 4 (page 10) and Table 7 (page 13) of:
* https://pub.smpte.org/latest/st436/s436m-2006.pdf
*/
typedef enum AVSmpte436mPayloadSampleCoding
{
/** only used for VBI */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA = 1,
/** only used for VBI */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_COLOR_DIFF = 2,
/** only used for VBI */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_1BIT_LUMA_AND_COLOR_DIFF = 3,
/** used for VBI and ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA = 4,
/** used for VBI and ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF = 5,
/** used for VBI and ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF = 6,
/** used for VBI and ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA = 7,
/** used for VBI and ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_COLOR_DIFF = 8,
/** used for VBI and ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_10BIT_LUMA_AND_COLOR_DIFF = 9,
/** only used for ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_WITH_PARITY_ERROR = 10,
/** only used for ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_COLOR_DIFF_WITH_PARITY_ERROR = 11,
/** only used for ANC */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_8BIT_LUMA_AND_COLOR_DIFF_WITH_PARITY_ERROR = 12,
/** not a real sample coding, just here to guarantee the enum is big enough */
AV_SMPTE_436M_PAYLOAD_SAMPLE_CODING_MAX = 0xFF,
} AVSmpte436mPayloadSampleCoding;
/** the payload capacity of AVSmpte291mAnc8bit (and of AVSmpte291mAnc10bit when that gets added) */
#define AV_SMPTE_291M_ANC_PAYLOAD_CAPACITY 0xFF
/**
* An ANC packet with an 8-bit payload.
* This can be decoded from AVSmpte436mCodedAnc::payload.
*
* Note: Some ANC packets need a 10-bit payload, if stored in this struct,
* the most-significant 2 bits of each sample are discarded.
*/
typedef struct AVSmpte291mAnc8bit {
uint8_t did;
uint8_t sdid_or_dbn;
uint8_t data_count;
uint8_t payload[AV_SMPTE_291M_ANC_PAYLOAD_CAPACITY];
uint8_t checksum;
} AVSmpte291mAnc8bit;
/** max number of samples that can be stored in the payload of AVSmpte436mCodedAnc */
#define AV_SMPTE_436M_CODED_ANC_SAMPLE_CAPACITY \
(AV_SMPTE_291M_ANC_PAYLOAD_CAPACITY + 4) /* 4 for did, sdid_or_dbn, data_count, and checksum */
/** max number of bytes that can be stored in the payload of AVSmpte436mCodedAnc */
#define AV_SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY (((AV_SMPTE_436M_CODED_ANC_SAMPLE_CAPACITY + 2) / 3) * 4)
/**
* An encoded ANC packet within a single AV_CODEC_ID_SMPTE_436M_ANC AVPacket's data.
* The repeated section of Table 7 (page 13) of:
* https://pub.smpte.org/latest/st436/s436m-2006.pdf
*/
typedef struct AVSmpte436mCodedAnc {
uint16_t line_number;
AVSmpte436mWrappingType wrapping_type;
AVSmpte436mPayloadSampleCoding payload_sample_coding;
uint16_t payload_sample_count;
uint32_t payload_array_length;
/** the payload, has size payload_array_length.
* can be decoded into AVSmpte291mAnc8bit
*/
uint8_t payload[AV_SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY];
} AVSmpte436mCodedAnc;
/**
* Validate a AVSmpte436mCodedAnc structure. Doesn't check if the payload is valid.
* @param[in] anc ANC packet to validate
* @return 0 on success, AVERROR codes otherwise.
*/
int av_smpte_436m_coded_anc_validate(const AVSmpte436mCodedAnc *anc);
/**
* Encode ANC packets into a single AV_CODEC_ID_SMPTE_436M_ANC AVPacket's data.
* @param[in] anc_packet_count number of ANC packets to encode
* @param[in] anc_packets the ANC packets 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.
*/
int av_smpte_436m_anc_encode(uint8_t *out, int size, int anc_packet_count, const AVSmpte436mCodedAnc *anc_packets);
struct AVPacket;
/**
* Append more ANC packets to a single AV_CODEC_ID_SMPTE_436M_ANC AVPacket's data.
* @param[in] anc_packet_count number of ANC packets to encode
* @param[in] anc_packets the ANC packets to encode
* @param pkt the AVPacket to append to.
* it must either be size 0 or contain valid SMPTE_436M_ANC data.
* @return 0 on success, AVERROR codes otherwise.
*/
int av_smpte_436m_anc_append(struct AVPacket *pkt, int anc_packet_count, const AVSmpte436mCodedAnc *anc_packets);
/**
* Set up iteration over the ANC packets in a single AV_CODEC_ID_SMPTE_436M_ANC AVPacket's data.
* @param[in] buf Pointer to the data from a AV_CODEC_ID_SMPTE_436M_ANC AVPacket.
* @param[in] buf_size Size of the data from a AV_CODEC_ID_SMPTE_436M_ANC AVPacket.
* @param[out] iter Pointer to the iterator.
* @return 0 on success, AVERROR codes otherwise.
*/
int av_smpte_436m_anc_iter_init(AVSmpte436mAncIterator *iter, const uint8_t *buf, int buf_size);
/**
* Get the next ANC packet from the iterator, advancing the iterator.
* @param[in,out] iter Pointer to the iterator.
* @param[out] anc The returned ANC packet.
* @return 0 on success, AVERROR_EOF when the iterator has reached the end, AVERROR codes otherwise.
*/
int av_smpte_436m_anc_iter_next(AVSmpte436mAncIterator *iter, AVSmpte436mCodedAnc *anc);
/**
* Get the minimum number of bytes needed to store a AVSmpte436mCodedAnc payload.
* @param sample_coding the payload sample coding
* @param sample_count the number of samples stored in the payload
* @return returns the minimum number of bytes needed, on error returns < 0.
* always <= SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY
*/
int av_smpte_436m_coded_anc_payload_size(AVSmpte436mPayloadSampleCoding sample_coding, uint16_t sample_count);
/**
* Decode a AVSmpte436mCodedAnc payload into AVSmpte291mAnc8bit
* @param[in] sample_coding the payload sample coding
* @param[in] sample_count the number of samples stored in the payload
* @param[in] payload the bytes storing the payload,
* the needed size can be obtained from
avpriv_smpte_436m_coded_anc_payload_size
* @param[in] log_ctx context pointer for av_log
* @param[out] out The decoded ANC packet.
* @return returns 0 on success, otherwise < 0.
*/
int av_smpte_291m_anc_8bit_decode(AVSmpte291mAnc8bit *out,
AVSmpte436mPayloadSampleCoding sample_coding,
uint16_t sample_count,
const uint8_t *payload,
void *log_ctx);
/**
* Fill in the correct checksum for a AVSmpte291mAnc8bit
* @param[in,out] anc The ANC packet.
*/
void av_smpte_291m_anc_8bit_fill_checksum(AVSmpte291mAnc8bit *anc);
/**
* Compute the sample count needed to encode a AVSmpte291mAnc8bit into a AVSmpte436mCodedAnc payload
* @param[in] anc The ANC packet.
* @param[in] sample_coding The sample coding.
* @param[in] log_ctx context pointer for av_log
* @return returns the sample count on success, otherwise < 0.
*/
int av_smpte_291m_anc_8bit_get_sample_count(const AVSmpte291mAnc8bit *anc,
AVSmpte436mPayloadSampleCoding sample_coding,
void *log_ctx);
/**
* Encode a AVSmpte291mAnc8bit into a AVSmpte436mCodedAnc
* @param[in] line_number the line number the ANC packet is on
* @param[in] wrapping_type the wrapping type
* @param[in] sample_coding the payload sample coding
* @param[in] payload the ANC packet to encode.
* @param[in] log_ctx context pointer for av_log
* @param[out] out The encoded ANC packet.
* @return returns 0 on success, otherwise < 0.
*/
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);
/** AVSmpte291mAnc8bit::did when carrying CTA-708 data (for AV_CODEC_ID_EIA_608) */
#define AV_SMPTE_291M_ANC_DID_CTA_708 0x61
/** AVSmpte291mAnc8bit::sdid_or_dbn when carrying CTA-708 data (for AV_CODEC_ID_EIA_608) */
#define AV_SMPTE_291M_ANC_SDID_CTA_708 0x1
/**
* Try to decode an ANC packet into EIA-608/CTA-708 data (AV_CODEC_ID_EIA_608). This
* @param[in] anc The ANC packet.
* @param[in] log_ctx Context pointer for av_log
* @param[out] cc_data the buffer to store the extracted EIA-608/CTA-708 data,
* you can pass NULL to not store the data.
* the required size is 3 * cc_count bytes.
* SMPTE_291M_ANC_PAYLOAD_CAPACITY is always enough size.
* @return returns cc_count (>= 0) on success, AVERROR(EAGAIN) if it wasn't a CTA-708 ANC packet, < 0 on error.
*/
int av_smpte_291m_anc_8bit_extract_cta_708(const AVSmpte291mAnc8bit *anc, uint8_t *cc_data, void *log_ctx);
#endif /* AVCODEC_SMPTE_436M_H */
|
