FFmpeg  4.3
spdifenc.c
Go to the documentation of this file.
1 /*
2  * IEC 61937 muxer
3  * Copyright (c) 2009 Bartlomiej Wolowiec
4  * Copyright (c) 2010, 2020 Anssi Hannula
5  * Copyright (c) 2010 Carl Eugen Hoyos
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * IEC-61937 encapsulation of various formats, used by S/PDIF
27  * @author Bartlomiej Wolowiec
28  * @author Anssi Hannula
29  * @author Carl Eugen Hoyos
30  */
31 
32 /*
33  * Terminology used in specification:
34  * data-burst - IEC61937 frame, contains header and encapsuled frame
35  * burst-preamble - IEC61937 frame header, contains 16-bit words named Pa, Pb, Pc and Pd
36  * burst-payload - encapsuled frame
37  * Pa, Pb - syncword - 0xF872, 0x4E1F
38  * Pc - burst-info, contains data-type (bits 0-6), error flag (bit 7), data-type-dependent info (bits 8-12)
39  * and bitstream number (bits 13-15)
40  * data-type - determines type of encapsuled frames
41  * Pd - length code (number of bits or bytes of encapsuled frame - according to data_type)
42  *
43  * IEC 61937 frames at normal usage start every specific count of bytes,
44  * dependent from data-type (spaces between packets are filled by zeros)
45  */
46 
47 #include <inttypes.h>
48 
49 #include "avformat.h"
50 #include "avio_internal.h"
51 #include "spdif.h"
52 #include "libavcodec/ac3.h"
53 #include "libavcodec/adts_parser.h"
54 #include "libavcodec/dca.h"
56 #include "libavutil/opt.h"
57 
58 typedef struct IEC61937Context {
59  const AVClass *av_class;
60  enum IEC61937DataType data_type;///< burst info - reference to type of payload of the data-burst
61  int length_code; ///< length code in bits or bytes, depending on data type
62  int pkt_offset; ///< data burst repetition period in bytes
63  uint8_t *buffer; ///< allocated buffer, used for swap bytes
64  int buffer_size; ///< size of allocated buffer
65 
66  uint8_t *out_buf; ///< pointer to the outgoing data before byte-swapping
67  int out_bytes; ///< amount of outgoing bytes
68 
69  int use_preamble; ///< preamble enabled (disabled for exactly pre-padded DTS)
70  int extra_bswap; ///< extra bswap for payload (for LE DTS => standard BE DTS)
71 
72  uint8_t *hd_buf[2]; ///< allocated buffers to concatenate hd audio frames
73  int hd_buf_size; ///< size of the hd audio buffer (eac3, dts4)
74  int hd_buf_count; ///< number of frames in the hd audio buffer (eac3)
75  int hd_buf_filled; ///< amount of bytes in the hd audio buffer (eac3, truehd)
76  int hd_buf_idx; ///< active hd buffer index (truehd)
77 
78  int dtshd_skip; ///< counter used for skipping DTS-HD frames
79 
80  uint16_t truehd_prev_time; ///< input_timing from the last frame
81  int truehd_prev_size; ///< previous frame size in bytes, including any MAT codes
82  int truehd_samples_per_frame; ///< samples per frame for padding calculation
83 
84  /* AVOptions: */
87 #define SPDIF_FLAG_BIGENDIAN 0x01
89 
90  /// function, which generates codec dependent header information.
91  /// Sets data_type and pkt_offset, and length_code, out_bytes, out_buf if necessary
94 
95 static const AVOption options[] = {
96 { "spdif_flags", "IEC 61937 encapsulation flags", offsetof(IEC61937Context, spdif_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },
97 { "be", "output in big-endian format (for use as s16be)", 0, AV_OPT_TYPE_CONST, {.i64 = SPDIF_FLAG_BIGENDIAN}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },
98 { "dtshd_rate", "mux complete DTS frames in HD mode at the specified IEC958 rate (in Hz, default 0=disabled)", offsetof(IEC61937Context, dtshd_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 768000, AV_OPT_FLAG_ENCODING_PARAM },
99 { "dtshd_fallback_time", "min secs to strip HD for after an overflow (-1: till the end, default 60)", offsetof(IEC61937Context, dtshd_fallback), AV_OPT_TYPE_INT, {.i64 = 60}, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
100 { NULL },
101 };
102 
103 static const AVClass spdif_class = {
104  .class_name = "spdif",
105  .item_name = av_default_item_name,
106  .option = options,
107  .version = LIBAVUTIL_VERSION_INT,
108 };
109 
111 {
112  IEC61937Context *ctx = s->priv_data;
113  int bitstream_mode = pkt->data[5] & 0x7;
114 
115  ctx->data_type = IEC61937_AC3 | (bitstream_mode << 8);
116  ctx->pkt_offset = AC3_FRAME_SIZE << 2;
117  return 0;
118 }
119 
121 {
122  IEC61937Context *ctx = s->priv_data;
123  static const uint8_t eac3_repeat[4] = {6, 3, 2, 1};
124  int repeat = 1;
125 
126  int bsid = pkt->data[5] >> 3;
127  if (bsid > 10 && (pkt->data[4] & 0xc0) != 0xc0) /* fscod */
128  repeat = eac3_repeat[(pkt->data[4] & 0x30) >> 4]; /* numblkscod */
129 
130  ctx->hd_buf[0] = av_fast_realloc(ctx->hd_buf[0], &ctx->hd_buf_size, ctx->hd_buf_filled + pkt->size);
131  if (!ctx->hd_buf[0])
132  return AVERROR(ENOMEM);
133 
134  memcpy(&ctx->hd_buf[0][ctx->hd_buf_filled], pkt->data, pkt->size);
135 
136  ctx->hd_buf_filled += pkt->size;
137  if (++ctx->hd_buf_count < repeat){
138  ctx->pkt_offset = 0;
139  return 0;
140  }
141  ctx->data_type = IEC61937_EAC3;
142  ctx->pkt_offset = 24576;
143  ctx->out_buf = ctx->hd_buf[0];
144  ctx->out_bytes = ctx->hd_buf_filled;
145  ctx->length_code = ctx->hd_buf_filled;
146 
147  ctx->hd_buf_count = 0;
148  ctx->hd_buf_filled = 0;
149  return 0;
150 }
151 
152 /*
153  * DTS type IV (DTS-HD) can be transmitted with various frame repetition
154  * periods; longer repetition periods allow for longer packets and therefore
155  * higher bitrate. Longer repetition periods mean that the constant bitrate of
156  * the output IEC 61937 stream is higher.
157  * The repetition period is measured in IEC 60958 frames (4 bytes).
158  */
159 static int spdif_dts4_subtype(int period)
160 {
161  switch (period) {
162  case 512: return 0x0;
163  case 1024: return 0x1;
164  case 2048: return 0x2;
165  case 4096: return 0x3;
166  case 8192: return 0x4;
167  case 16384: return 0x5;
168  }
169  return -1;
170 }
171 
172 static int spdif_header_dts4(AVFormatContext *s, AVPacket *pkt, int core_size,
173  int sample_rate, int blocks)
174 {
175  IEC61937Context *ctx = s->priv_data;
176  static const char dtshd_start_code[10] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe };
177  int pkt_size = pkt->size;
178  int period;
179  int subtype;
180 
181  if (!core_size) {
182  av_log(s, AV_LOG_ERROR, "HD mode not supported for this format\n");
183  return AVERROR(EINVAL);
184  }
185 
186  if (!sample_rate) {
187  av_log(s, AV_LOG_ERROR, "Unknown DTS sample rate for HD\n");
188  return AVERROR_INVALIDDATA;
189  }
190 
191  period = ctx->dtshd_rate * (blocks << 5) / sample_rate;
192  subtype = spdif_dts4_subtype(period);
193 
194  if (subtype < 0) {
195  av_log(s, AV_LOG_ERROR, "Specified HD rate of %d Hz would require an "
196  "impossible repetition period of %d for the current DTS stream"
197  " (blocks = %d, sample rate = %d)\n", ctx->dtshd_rate, period,
198  blocks << 5, sample_rate);
199  return AVERROR(EINVAL);
200  }
201 
202  /* set pkt_offset and DTS IV subtype according to the requested output
203  * rate */
204  ctx->pkt_offset = period * 4;
205  ctx->data_type = IEC61937_DTSHD | subtype << 8;
206 
207  /* If the bitrate is too high for transmitting at the selected
208  * repetition period setting, strip DTS-HD until a good amount
209  * of consecutive non-overflowing HD frames have been observed.
210  * This generally only happens if the caller is cramming a Master
211  * Audio stream into 192kHz IEC 60958 (which may or may not fit). */
212  if (sizeof(dtshd_start_code) + 2 + pkt_size
213  > ctx->pkt_offset - BURST_HEADER_SIZE && core_size) {
214  if (!ctx->dtshd_skip)
215  av_log(s, AV_LOG_WARNING, "DTS-HD bitrate too high, "
216  "temporarily sending core only\n");
217  if (ctx->dtshd_fallback > 0)
218  ctx->dtshd_skip = sample_rate * ctx->dtshd_fallback / (blocks << 5);
219  else
220  /* skip permanently (dtshd_fallback == -1) or just once
221  * (dtshd_fallback == 0) */
222  ctx->dtshd_skip = 1;
223  }
224  if (ctx->dtshd_skip && core_size) {
225  pkt_size = core_size;
226  if (ctx->dtshd_fallback >= 0)
227  --ctx->dtshd_skip;
228  }
229 
230  ctx->out_bytes = sizeof(dtshd_start_code) + 2 + pkt_size;
231 
232  /* Align so that (length_code & 0xf) == 0x8. This is reportedly needed
233  * with some receivers, but the exact requirement is unconfirmed. */
234  ctx->length_code = FFALIGN(ctx->out_bytes + 0x8, 0x10) - 0x8;
235 
236  av_fast_malloc(&ctx->hd_buf[0], &ctx->hd_buf_size, ctx->out_bytes);
237  if (!ctx->hd_buf[0])
238  return AVERROR(ENOMEM);
239 
240  ctx->out_buf = ctx->hd_buf[0];
241 
242  memcpy(ctx->hd_buf[0], dtshd_start_code, sizeof(dtshd_start_code));
243  AV_WB16(ctx->hd_buf[0] + sizeof(dtshd_start_code), pkt_size);
244  memcpy(ctx->hd_buf[0] + sizeof(dtshd_start_code) + 2, pkt->data, pkt_size);
245 
246  return 0;
247 }
248 
250 {
251  IEC61937Context *ctx = s->priv_data;
252  uint32_t syncword_dts = AV_RB32(pkt->data);
253  int blocks;
254  int sample_rate = 0;
255  int core_size = 0;
256 
257  if (pkt->size < 9)
258  return AVERROR_INVALIDDATA;
259 
260  switch (syncword_dts) {
262  blocks = (AV_RB16(pkt->data + 4) >> 2) & 0x7f;
263  core_size = ((AV_RB24(pkt->data + 5) >> 4) & 0x3fff) + 1;
264  sample_rate = avpriv_dca_sample_rates[(pkt->data[8] >> 2) & 0x0f];
265  break;
267  blocks = (AV_RL16(pkt->data + 4) >> 2) & 0x7f;
268  ctx->extra_bswap = 1;
269  break;
271  blocks =
272  (((pkt->data[5] & 0x07) << 4) | ((pkt->data[6] & 0x3f) >> 2));
273  break;
275  blocks =
276  (((pkt->data[4] & 0x07) << 4) | ((pkt->data[7] & 0x3f) >> 2));
277  ctx->extra_bswap = 1;
278  break;
280  /* We only handle HD frames that are paired with core. However,
281  sometimes DTS-HD streams with core have a stray HD frame without
282  core in the beginning of the stream. */
283  av_log(s, AV_LOG_ERROR, "stray DTS-HD frame\n");
284  return AVERROR_INVALIDDATA;
285  default:
286  av_log(s, AV_LOG_ERROR, "bad DTS syncword 0x%"PRIx32"\n", syncword_dts);
287  return AVERROR_INVALIDDATA;
288  }
289  blocks++;
290 
291  if (ctx->dtshd_rate)
292  /* DTS type IV output requested */
293  return spdif_header_dts4(s, pkt, core_size, sample_rate, blocks);
294 
295  switch (blocks) {
296  case 512 >> 5: ctx->data_type = IEC61937_DTS1; break;
297  case 1024 >> 5: ctx->data_type = IEC61937_DTS2; break;
298  case 2048 >> 5: ctx->data_type = IEC61937_DTS3; break;
299  default:
300  av_log(s, AV_LOG_ERROR, "%i samples in DTS frame not supported\n",
301  blocks << 5);
302  return AVERROR(ENOSYS);
303  }
304 
305  /* discard extraneous data by default */
306  if (core_size && core_size < pkt->size) {
307  ctx->out_bytes = core_size;
308  ctx->length_code = core_size << 3;
309  }
310 
311  ctx->pkt_offset = blocks << 7;
312 
313  if (ctx->out_bytes == ctx->pkt_offset) {
314  /* The DTS stream fits exactly into the output stream, so skip the
315  * preamble as it would not fit in there. This is the case for dts
316  * discs and dts-in-wav. */
317  ctx->use_preamble = 0;
318  } else if (ctx->out_bytes > ctx->pkt_offset - BURST_HEADER_SIZE) {
319  avpriv_request_sample(s, "Unrecognized large DTS frame");
320  /* This will fail with a "bitrate too high" in the caller */
321  }
322 
323  return 0;
324 }
325 
326 static const enum IEC61937DataType mpeg_data_type[2][3] = {
327  // LAYER1 LAYER2 LAYER3
330 };
331 
333 {
334  IEC61937Context *ctx = s->priv_data;
335  int version = (pkt->data[1] >> 3) & 3;
336  int layer = 3 - ((pkt->data[1] >> 1) & 3);
337  int extension = pkt->data[2] & 1;
338 
339  if (layer == 3 || version == 1) {
340  av_log(s, AV_LOG_ERROR, "Wrong MPEG file format\n");
341  return AVERROR_INVALIDDATA;
342  }
343  av_log(s, AV_LOG_DEBUG, "version: %i layer: %i extension: %i\n", version, layer, extension);
344  if (version == 2 && extension) {
345  ctx->data_type = IEC61937_MPEG2_EXT;
346  ctx->pkt_offset = 4608;
347  } else {
348  ctx->data_type = mpeg_data_type [version & 1][layer];
349  ctx->pkt_offset = spdif_mpeg_pkt_offset[version & 1][layer];
350  }
351  // TODO Data type dependent info (normal/karaoke, dynamic range control)
352  return 0;
353 }
354 
356 {
357  IEC61937Context *ctx = s->priv_data;
358  uint32_t samples;
359  uint8_t frames;
360  int ret;
361 
363  if (ret < 0) {
364  av_log(s, AV_LOG_ERROR, "Wrong AAC file format\n");
365  return ret;
366  }
367 
368  ctx->pkt_offset = samples << 2;
369  switch (frames) {
370  case 1:
371  ctx->data_type = IEC61937_MPEG2_AAC;
372  break;
373  case 2:
374  ctx->data_type = IEC61937_MPEG2_AAC_LSF_2048;
375  break;
376  case 4:
377  ctx->data_type = IEC61937_MPEG2_AAC_LSF_4096;
378  break;
379  default:
381  "%"PRIu32" samples in AAC frame not supported\n", samples);
382  return AVERROR(EINVAL);
383  }
384  //TODO Data type dependent info (LC profile/SBR)
385  return 0;
386 }
387 
388 
389 /*
390  * It seems Dolby TrueHD frames have to be encapsulated in MAT frames before
391  * they can be encapsulated in IEC 61937.
392  */
393 #define MAT_PKT_OFFSET 61440
394 #define MAT_FRAME_SIZE 61424
395 
396 static const uint8_t mat_start_code[20] = {
397  0x07, 0x9E, 0x00, 0x03, 0x84, 0x01, 0x01, 0x01, 0x80, 0x00, 0x56, 0xA5, 0x3B, 0xF4, 0x81, 0x83,
398  0x49, 0x80, 0x77, 0xE0,
399 };
400 static const uint8_t mat_middle_code[12] = {
401  0xC3, 0xC1, 0x42, 0x49, 0x3B, 0xFA, 0x82, 0x83, 0x49, 0x80, 0x77, 0xE0,
402 };
403 static const uint8_t mat_end_code[16] = {
404  0xC3, 0xC2, 0xC0, 0xC4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x97, 0x11,
405 };
406 
407 #define MAT_CODE(position, data) { .pos = position, .code = data, .len = sizeof(data) }
408 
409 static const struct {
410  unsigned int pos;
411  const uint8_t *code;
412  unsigned int len;
413 } mat_codes[] = {
415  MAT_CODE(30708, mat_middle_code),
417 };
418 
420 {
421  IEC61937Context *ctx = s->priv_data;
422  uint8_t *hd_buf = ctx->hd_buf[ctx->hd_buf_idx];
423  int ratebits;
424  int padding_remaining = 0;
425  uint16_t input_timing;
426  int total_frame_size = pkt->size;
427  const uint8_t *dataptr = pkt->data;
428  int data_remaining = pkt->size;
429  int have_pkt = 0;
430  int next_code_idx;
431 
432  if (pkt->size < 10)
433  return AVERROR_INVALIDDATA;
434 
435  if (AV_RB24(pkt->data + 4) == 0xf8726f) {
436  /* major sync unit, fetch sample rate */
437  if (pkt->data[7] == 0xba)
438  ratebits = pkt->data[8] >> 4;
439  else if (pkt->data[7] == 0xbb)
440  ratebits = pkt->data[9] >> 4;
441  else
442  return AVERROR_INVALIDDATA;
443 
444  ctx->truehd_samples_per_frame = 40 << (ratebits & 3);
445  av_log(s, AV_LOG_TRACE, "TrueHD samples per frame: %d\n",
446  ctx->truehd_samples_per_frame);
447  }
448 
449  if (!ctx->truehd_samples_per_frame)
450  return AVERROR_INVALIDDATA;
451 
452  input_timing = AV_RB16(pkt->data + 2);
453  if (ctx->truehd_prev_size) {
454  uint16_t delta_samples = input_timing - ctx->truehd_prev_time;
455  /*
456  * One multiple-of-48kHz frame is 1/1200 sec and the IEC 61937 rate
457  * is 768kHz = 768000*4 bytes/sec.
458  * The nominal space per frame is therefore
459  * (768000*4 bytes/sec) * (1/1200 sec) = 2560 bytes.
460  * For multiple-of-44.1kHz frames: 1/1102.5 sec, 705.6kHz, 2560 bytes.
461  *
462  * 2560 is divisible by truehd_samples_per_frame.
463  */
464  int delta_bytes = delta_samples * 2560 / ctx->truehd_samples_per_frame;
465 
466  /* padding needed before this frame */
467  padding_remaining = delta_bytes - ctx->truehd_prev_size;
468 
469  av_log(s, AV_LOG_TRACE, "delta_samples: %"PRIu16", delta_bytes: %d\n",
470  delta_samples, delta_bytes);
471 
472  /* sanity check */
473  if (padding_remaining < 0 || padding_remaining >= MAT_FRAME_SIZE / 2) {
474  avpriv_request_sample(s, "Unusual frame timing: %"PRIu16" => %"PRIu16", %d samples/frame",
475  ctx->truehd_prev_time, input_timing, ctx->truehd_samples_per_frame);
476  padding_remaining = 0;
477  }
478  }
479 
480  for (next_code_idx = 0; next_code_idx < FF_ARRAY_ELEMS(mat_codes); next_code_idx++)
481  if (ctx->hd_buf_filled <= mat_codes[next_code_idx].pos)
482  break;
483 
484  if (next_code_idx >= FF_ARRAY_ELEMS(mat_codes))
485  return AVERROR_BUG;
486 
487  while (padding_remaining || data_remaining ||
488  mat_codes[next_code_idx].pos == ctx->hd_buf_filled) {
489 
490  if (mat_codes[next_code_idx].pos == ctx->hd_buf_filled) {
491  /* time to insert MAT code */
492  int code_len = mat_codes[next_code_idx].len;
493  int code_len_remaining = code_len;
494  memcpy(hd_buf + mat_codes[next_code_idx].pos,
495  mat_codes[next_code_idx].code, code_len);
496  ctx->hd_buf_filled += code_len;
497 
498  next_code_idx++;
499  if (next_code_idx == FF_ARRAY_ELEMS(mat_codes)) {
500  next_code_idx = 0;
501 
502  /* this was the last code, move to the next MAT frame */
503  have_pkt = 1;
504  ctx->out_buf = hd_buf;
505  ctx->hd_buf_idx ^= 1;
506  hd_buf = ctx->hd_buf[ctx->hd_buf_idx];
507  ctx->hd_buf_filled = 0;
508 
509  /* inter-frame gap has to be counted as well, add it */
510  code_len_remaining += MAT_PKT_OFFSET - MAT_FRAME_SIZE;
511  }
512 
513  if (padding_remaining) {
514  /* consider the MAT code as padding */
515  int counted_as_padding = FFMIN(padding_remaining,
516  code_len_remaining);
517  padding_remaining -= counted_as_padding;
518  code_len_remaining -= counted_as_padding;
519  }
520  /* count the remainder of the code as part of frame size */
521  if (code_len_remaining)
522  total_frame_size += code_len_remaining;
523  }
524 
525  if (padding_remaining) {
526  int padding_to_insert = FFMIN(mat_codes[next_code_idx].pos - ctx->hd_buf_filled,
527  padding_remaining);
528 
529  memset(hd_buf + ctx->hd_buf_filled, 0, padding_to_insert);
530  ctx->hd_buf_filled += padding_to_insert;
531  padding_remaining -= padding_to_insert;
532 
533  if (padding_remaining)
534  continue; /* time to insert MAT code */
535  }
536 
537  if (data_remaining) {
538  int data_to_insert = FFMIN(mat_codes[next_code_idx].pos - ctx->hd_buf_filled,
539  data_remaining);
540 
541  memcpy(hd_buf + ctx->hd_buf_filled, dataptr, data_to_insert);
542  ctx->hd_buf_filled += data_to_insert;
543  dataptr += data_to_insert;
544  data_remaining -= data_to_insert;
545  }
546  }
547 
548  ctx->truehd_prev_size = total_frame_size;
549  ctx->truehd_prev_time = input_timing;
550 
551  av_log(s, AV_LOG_TRACE, "TrueHD frame inserted, total size %d, buffer position %d\n",
552  total_frame_size, ctx->hd_buf_filled);
553 
554  if (!have_pkt) {
555  ctx->pkt_offset = 0;
556  return 0;
557  }
558 
559  ctx->data_type = IEC61937_TRUEHD;
560  ctx->pkt_offset = MAT_PKT_OFFSET;
561  ctx->out_bytes = MAT_FRAME_SIZE;
562  ctx->length_code = MAT_FRAME_SIZE;
563  return 0;
564 }
565 
567 {
568  IEC61937Context *ctx = s->priv_data;
569 
570  switch (s->streams[0]->codecpar->codec_id) {
571  case AV_CODEC_ID_AC3:
572  ctx->header_info = spdif_header_ac3;
573  break;
574  case AV_CODEC_ID_EAC3:
575  ctx->header_info = spdif_header_eac3;
576  break;
577  case AV_CODEC_ID_MP1:
578  case AV_CODEC_ID_MP2:
579  case AV_CODEC_ID_MP3:
580  ctx->header_info = spdif_header_mpeg;
581  break;
582  case AV_CODEC_ID_DTS:
583  ctx->header_info = spdif_header_dts;
584  break;
585  case AV_CODEC_ID_AAC:
586  ctx->header_info = spdif_header_aac;
587  break;
588  case AV_CODEC_ID_TRUEHD:
589  case AV_CODEC_ID_MLP:
590  ctx->header_info = spdif_header_truehd;
591  for (int i = 0; i < FF_ARRAY_ELEMS(ctx->hd_buf); i++) {
592  ctx->hd_buf[i] = av_malloc(MAT_FRAME_SIZE);
593  if (!ctx->hd_buf[i])
594  return AVERROR(ENOMEM);
595  }
596  break;
597  default:
598  avpriv_report_missing_feature(s, "Codec %d",
599  s->streams[0]->codecpar->codec_id);
600  return AVERROR_PATCHWELCOME;
601  }
602  return 0;
603 }
604 
606 {
607  IEC61937Context *ctx = s->priv_data;
608  av_freep(&ctx->buffer);
609  for (int i = 0; i < FF_ARRAY_ELEMS(ctx->hd_buf); i++)
610  av_freep(&ctx->hd_buf[i]);
611 }
612 
614  AVIOContext *pb, unsigned int val)
615 {
616  if (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)
617  avio_wb16(pb, val);
618  else
619  avio_wl16(pb, val);
620 }
621 
623 {
624  IEC61937Context *ctx = s->priv_data;
625  int ret, padding;
626 
627  ctx->out_buf = pkt->data;
628  ctx->out_bytes = pkt->size;
629  ctx->length_code = FFALIGN(pkt->size, 2) << 3;
630  ctx->use_preamble = 1;
631  ctx->extra_bswap = 0;
632 
633  ret = ctx->header_info(s, pkt);
634  if (ret < 0)
635  return ret;
636  if (!ctx->pkt_offset)
637  return 0;
638 
639  padding = (ctx->pkt_offset - ctx->use_preamble * BURST_HEADER_SIZE - ctx->out_bytes) & ~1;
640  if (padding < 0) {
641  av_log(s, AV_LOG_ERROR, "bitrate is too high\n");
642  return AVERROR(EINVAL);
643  }
644 
645  if (ctx->use_preamble) {
646  spdif_put_16(ctx, s->pb, SYNCWORD1); //Pa
647  spdif_put_16(ctx, s->pb, SYNCWORD2); //Pb
648  spdif_put_16(ctx, s->pb, ctx->data_type); //Pc
649  spdif_put_16(ctx, s->pb, ctx->length_code);//Pd
650  }
651 
652  if (ctx->extra_bswap ^ (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)) {
653  avio_write(s->pb, ctx->out_buf, ctx->out_bytes & ~1);
654  } else {
655  av_fast_malloc(&ctx->buffer, &ctx->buffer_size, ctx->out_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
656  if (!ctx->buffer)
657  return AVERROR(ENOMEM);
658  ff_spdif_bswap_buf16((uint16_t *)ctx->buffer, (uint16_t *)ctx->out_buf, ctx->out_bytes >> 1);
659  avio_write(s->pb, ctx->buffer, ctx->out_bytes & ~1);
660  }
661 
662  /* a final lone byte has to be MSB aligned */
663  if (ctx->out_bytes & 1)
664  spdif_put_16(ctx, s->pb, ctx->out_buf[ctx->out_bytes - 1] << 8);
665 
666  ffio_fill(s->pb, 0, padding);
667 
668  av_log(s, AV_LOG_DEBUG, "type=%x len=%i pkt_offset=%i\n",
669  ctx->data_type, ctx->out_bytes, ctx->pkt_offset);
670 
671  return 0;
672 }
673 
675  .name = "spdif",
676  .long_name = NULL_IF_CONFIG_SMALL("IEC 61937 (used on S/PDIF - IEC958)"),
677  .extensions = "spdif",
678  .priv_data_size = sizeof(IEC61937Context),
679  .audio_codec = AV_CODEC_ID_AC3,
680  .video_codec = AV_CODEC_ID_NONE,
683  .deinit = spdif_deinit,
685  .priv_class = &spdif_class,
686 };
IEC61937Context::truehd_samples_per_frame
int truehd_samples_per_frame
samples per frame for padding calculation
Definition: spdifenc.c:82
mpeg_data_type
static enum IEC61937DataType mpeg_data_type[2][3]
Definition: spdifenc.c:326
IEC61937Context::extra_bswap
int extra_bswap
extra bswap for payload (for LE DTS => standard BE DTS)
Definition: spdifenc.c:70
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
MAT_PKT_OFFSET
#define MAT_PKT_OFFSET
Definition: spdifenc.c:393
IEC61937_MPEG2_AAC_LSF_4096
@ IEC61937_MPEG2_AAC_LSF_4096
MPEG-2 AAC ADTS quarter-rate low sampling frequency.
Definition: spdif.h:50
spdif_header_mpeg
static int spdif_header_mpeg(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:332
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:413
IEC61937DataType
IEC61937DataType
Definition: spdif.h:32
AVOutputFormat::name
const char * name
Definition: avformat.h:491
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
IEC61937Context::spdif_flags
int spdif_flags
Definition: spdifenc.c:88
dca.h
spdif_header_aac
static int spdif_header_aac(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:355
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
spdif_write_packet
static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:622
IEC61937Context::truehd_prev_time
uint16_t truehd_prev_time
input_timing from the last frame
Definition: spdifenc.c:80
IEC61937Context::truehd_prev_size
int truehd_prev_size
previous frame size in bytes, including any MAT codes
Definition: spdifenc.c:81
DCA_SYNCWORD_CORE_14B_BE
#define DCA_SYNCWORD_CORE_14B_BE
Definition: dca_syncwords.h:24
IEC61937Context::pkt_offset
int pkt_offset
data burst repetition period in bytes
Definition: spdifenc.c:62
mat_start_code
static const uint8_t mat_start_code[20]
Definition: spdifenc.c:396
AVPacket::data
uint8_t * data
Definition: packet.h:355
IEC61937Context::buffer_size
int buffer_size
size of allocated buffer
Definition: spdifenc.c:64
AVOption
AVOption.
Definition: opt.h:246
AV_RB16
#define AV_RB16
Definition: intreadwrite.h:53
len
unsigned int len
Definition: spdifenc.c:412
spdif_header_truehd
static int spdif_header_truehd(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:419
IEC61937_MPEG2_LAYER1_LSF
@ IEC61937_MPEG2_LAYER1_LSF
MPEG-2, layer-1 low sampling frequency.
Definition: spdif.h:38
samples
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new samples
Definition: fate.txt:139
spdif_put_16
static av_always_inline void spdif_put_16(IEC61937Context *ctx, AVIOContext *pb, unsigned int val)
Definition: spdifenc.c:613
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:454
sample_rate
sample_rate
Definition: ffmpeg_filter.c:192
av_adts_header_parse
int av_adts_header_parse(const uint8_t *buf, uint32_t *samples, uint8_t *frames)
Extract the number of samples and frames from AAC data.
Definition: adts_parser.c:27
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:447
spdif_class
static const AVClass spdif_class
Definition: spdifenc.c:103
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AV_RB24
#define AV_RB24
Definition: intreadwrite.h:64
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:411
spdif_header_dts4
static int spdif_header_dts4(AVFormatContext *s, AVPacket *pkt, int core_size, int sample_rate, int blocks)
Definition: spdifenc.c:172
SPDIF_FLAG_BIGENDIAN
#define SPDIF_FLAG_BIGENDIAN
Definition: spdifenc.c:87
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
ff_spdif_bswap_buf16
void ff_spdif_bswap_buf16(uint16_t *dst, const uint16_t *src, int w)
Definition: spdif.c:26
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:478
IEC61937_MPEG2_EXT
@ IEC61937_MPEG2_EXT
MPEG-2 data with extension.
Definition: spdif.h:36
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
IEC61937Context
Definition: spdifenc.c:58
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:410
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_RL16
#define AV_RL16
Definition: intreadwrite.h:42
code
const uint8_t * code
Definition: spdifenc.c:411
IEC61937Context::data_type
enum IEC61937DataType data_type
burst info - reference to type of payload of the data-burst
Definition: spdifenc.c:60
dca_syncwords.h
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
IEC61937_AC3
@ IEC61937_AC3
AC-3 data.
Definition: spdif.h:33
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
IEC61937Context::av_class
const AVClass * av_class
Definition: spdifenc.c:59
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
period
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period
Definition: writing_filters.txt:89
spdif_header_dts
static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:249
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
IEC61937Context::hd_buf_count
int hd_buf_count
number of frames in the hd audio buffer (eac3)
Definition: spdifenc.c:74
IEC61937_DTSHD
@ IEC61937_DTSHD
DTS HD data.
Definition: spdif.h:47
AV_RB32
#define AV_RB32
Definition: intreadwrite.h:130
ff_spdif_muxer
AVOutputFormat ff_spdif_muxer
Definition: spdifenc.c:674
IEC61937_DTS3
@ IEC61937_DTS3
DTS type III (2048 samples)
Definition: spdif.h:43
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:450
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:412
IEC61937_MPEG1_LAYER23
@ IEC61937_MPEG1_LAYER23
MPEG-1 layer 2 or 3 data or MPEG-2 without extension.
Definition: spdif.h:35
spdif_header_eac3
static int spdif_header_eac3(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:120
DCA_SYNCWORD_CORE_BE
#define DCA_SYNCWORD_CORE_BE
Definition: dca_syncwords.h:22
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:186
IEC61937Context::header_info
int(* header_info)(AVFormatContext *s, AVPacket *pkt)
function, which generates codec dependent header information.
Definition: spdifenc.c:92
IEC61937_DTS2
@ IEC61937_DTS2
DTS type II (1024 samples)
Definition: spdif.h:42
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:414
mat_end_code
static const uint8_t mat_end_code[16]
Definition: spdifenc.c:403
IEC61937Context::out_bytes
int out_bytes
amount of outgoing bytes
Definition: spdifenc.c:67
size
int size
Definition: twinvq_data.h:11134
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
DCA_SYNCWORD_CORE_14B_LE
#define DCA_SYNCWORD_CORE_14B_LE
Definition: dca_syncwords.h:25
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:213
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
IEC61937Context::length_code
int length_code
length code in bits or bytes, depending on data type
Definition: spdifenc.c:61
IEC61937Context::dtshd_rate
int dtshd_rate
Definition: spdifenc.c:85
IEC61937_DTS1
@ IEC61937_DTS1
DTS type I (512 samples)
Definition: spdif.h:41
spdif_write_header
static int spdif_write_header(AVFormatContext *s)
Definition: spdifenc.c:566
version
version
Definition: libkvazaar.c:292
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:701
IEC61937Context::buffer
uint8_t * buffer
allocated buffer, used for swap bytes
Definition: spdifenc.c:63
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
AVOutputFormat
Definition: avformat.h:490
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
avio_internal.h
IEC61937Context::dtshd_skip
int dtshd_skip
counter used for skipping DTS-HD frames
Definition: spdifenc.c:78
av_always_inline
#define av_always_inline
Definition: attributes.h:49
IEC61937Context::use_preamble
int use_preamble
preamble enabled (disabled for exactly pre-padded DTS)
Definition: spdifenc.c:69
IEC61937_MPEG1_LAYER1
@ IEC61937_MPEG1_LAYER1
MPEG-1 layer 1.
Definition: spdif.h:34
uint8_t
uint8_t
Definition: audio_convert.c:194
IEC61937_EAC3
@ IEC61937_EAC3
E-AC-3 data.
Definition: spdif.h:51
IEC61937Context::dtshd_fallback
int dtshd_fallback
Definition: spdifenc.c:86
DCA_SYNCWORD_SUBSTREAM
#define DCA_SYNCWORD_SUBSTREAM
Definition: dca_syncwords.h:32
IEC61937_MPEG2_AAC_LSF_2048
@ IEC61937_MPEG2_AAC_LSF_2048
MPEG-2 AAC ADTS half-rate low sampling frequency.
Definition: spdif.h:49
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
adts_parser.h
pos
unsigned int pos
Definition: spdifenc.c:410
avformat.h
SYNCWORD2
#define SYNCWORD2
Definition: spdif.h:29
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
IEC61937Context::hd_buf_size
int hd_buf_size
size of the hd audio buffer (eac3, dts4)
Definition: spdifenc.c:73
BURST_HEADER_SIZE
#define BURST_HEADER_SIZE
Definition: spdif.h:30
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
spdif_dts4_subtype
static int spdif_dts4_subtype(int period)
Definition: spdifenc.c:159
IEC61937_TRUEHD
@ IEC61937_TRUEHD
TrueHD data.
Definition: spdif.h:52
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
IEC61937Context::out_buf
uint8_t * out_buf
pointer to the outgoing data before byte-swapping
Definition: spdifenc.c:66
IEC61937Context::hd_buf_filled
int hd_buf_filled
amount of bytes in the hd audio buffer (eac3, truehd)
Definition: spdifenc.c:75
MAT_CODE
#define MAT_CODE(position, data)
Definition: spdifenc.c:407
AC3_FRAME_SIZE
#define AC3_FRAME_SIZE
Definition: ac3.h:38
IEC61937Context::hd_buf
uint8_t * hd_buf[2]
allocated buffers to concatenate hd audio frames
Definition: spdifenc.c:72
DCA_SYNCWORD_CORE_LE
#define DCA_SYNCWORD_CORE_LE
Definition: dca_syncwords.h:23
IEC61937_MPEG2_LAYER2_LSF
@ IEC61937_MPEG2_LAYER2_LSF
MPEG-2, layer-2 low sampling frequency.
Definition: spdif.h:39
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: packet.h:332
ac3.h
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:502
spdif_header_ac3
static int spdif_header_ac3(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:110
mat_middle_code
static const uint8_t mat_middle_code[12]
Definition: spdifenc.c:400
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:222
ffio_fill
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:199
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:453
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:564
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
mat_codes
static const struct @279 mat_codes[]
options
static const AVOption options[]
Definition: spdifenc.c:95
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
IEC61937_MPEG2_AAC
@ IEC61937_MPEG2_AAC
MPEG-2 AAC ADTS.
Definition: spdif.h:37
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
spdif_deinit
static void spdif_deinit(AVFormatContext *s)
Definition: spdifenc.c:605
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
MAT_FRAME_SIZE
#define MAT_FRAME_SIZE
Definition: spdifenc.c:394
IEC61937Context::hd_buf_idx
int hd_buf_idx
active hd buffer index (truehd)
Definition: spdifenc.c:76
avpriv_dca_sample_rates
const uint32_t avpriv_dca_sample_rates[16]
Definition: dca.c:36
int
int
Definition: ffmpeg_filter.c:192
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:452
spdif_mpeg_pkt_offset
static const uint16_t spdif_mpeg_pkt_offset[2][3]
Definition: spdif.h:55
IEC61937_MPEG2_LAYER3_LSF
@ IEC61937_MPEG2_LAYER3_LSF
MPEG-2, layer-3 low sampling frequency.
Definition: spdif.h:40
spdif.h
SYNCWORD1
#define SYNCWORD1
Definition: spdif.h:28
AV_CODEC_ID_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:439