FFmpeg: libavformat/spdifenc.c Source File

FFmpeg
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 "mux.h"
52 #include "spdif.h"
53 #include "libavcodec/ac3defs.h"
54 #include "libavcodec/adts_parser.h"
55 #include "libavcodec/dca.h"
56 #include "libavcodec/dca_syncwords.h"
57 #include "libavutil/opt.h"
58 
59  typedef struct IEC61937Context {
60   const AVClass *av_class;
61   enum IEC61937DataType data_type;///< burst info - reference to type of payload of the data-burst
62   int length_code; ///< length code in bits or bytes, depending on data type
63   int pkt_offset; ///< data burst repetition period in bytes
64   uint8_t *buffer; ///< allocated buffer, used for swap bytes
65   int buffer_size; ///< size of allocated buffer
66 
67   const uint8_t *out_buf; ///< pointer to the outgoing data before byte-swapping
68   int out_bytes; ///< amount of outgoing bytes
69 
70   int use_preamble; ///< preamble enabled (disabled for exactly pre-padded DTS)
71   int extra_bswap; ///< extra bswap for payload (for LE DTS => standard BE DTS)
72 
73   uint8_t *hd_buf[2]; ///< allocated buffers to concatenate hd audio frames
74   int hd_buf_size; ///< size of the hd audio buffer (eac3, dts4)
75   int hd_buf_count; ///< number of frames in the hd audio buffer (eac3)
76   int hd_buf_filled; ///< amount of bytes in the hd audio buffer (eac3, truehd)
77   int hd_buf_idx; ///< active hd buffer index (truehd)
78 
79   int dtshd_skip; ///< counter used for skipping DTS-HD frames
80 
81   uint16_t truehd_prev_time; ///< input_timing from the last frame
82   int truehd_prev_size; ///< previous frame size in bytes, including any MAT codes
83   int truehd_samples_per_frame; ///< samples per frame for padding calculation
84 
85  /* AVOptions: */
86   int dtshd_rate;
87   int dtshd_fallback;
88  #define SPDIF_FLAG_BIGENDIAN 0x01
89   int spdif_flags;
90 
91  /// function, which generates codec dependent header information.
92  /// Sets data_type and pkt_offset, and length_code, out_bytes, out_buf if necessary
93   int (*header_info) (AVFormatContext *s, AVPacket *pkt);
94 } IEC61937Context;
95 
96  static const AVOption options[] = {
97 { "spdif_flags", "IEC 61937 encapsulation flags", offsetof(IEC61937Context, spdif_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, .unit = "spdif_flags" },
98 { "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, .unit = "spdif_flags" },
99 { "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 },
100 { "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 },
101 { NULL },
102 };
103 
104  static const AVClass spdif_class = {
105  .class_name = "spdif",
106  .item_name = av_default_item_name,
107  .option = options,
108  .version = LIBAVUTIL_VERSION_INT,
109 };
110 
111  static int spdif_header_ac3(AVFormatContext *s, AVPacket *pkt)
112 {
113  IEC61937Context *ctx = s->priv_data;
114  int bitstream_mode = pkt->data[5] & 0x7;
115 
116  ctx->data_type = IEC61937_AC3 | (bitstream_mode << 8);
117  ctx->pkt_offset = AC3_FRAME_SIZE << 2;
118  return 0;
119 }
120 
121  static int spdif_header_eac3(AVFormatContext *s, AVPacket *pkt)
122 {
123  IEC61937Context *ctx = s->priv_data;
124  static const uint8_t eac3_repeat[4] = {6, 3, 2, 1};
125  int repeat = 1;
126  uint8_t *tmp;
127 
128  int bsid = pkt->data[5] >> 3;
129  if (bsid > 10 && (pkt->data[4] & 0xc0) != 0xc0) /* fscod */
130  repeat = eac3_repeat[(pkt->data[4] & 0x30) >> 4]; /* numblkscod */
131 
132  tmp = av_fast_realloc(ctx->hd_buf[0], &ctx->hd_buf_size, ctx->hd_buf_filled + pkt->size);
133  if (!tmp)
134  return AVERROR(ENOMEM);
135  ctx->hd_buf[0] = tmp;
136 
137  memcpy(&ctx->hd_buf[0][ctx->hd_buf_filled], pkt->data, pkt->size);
138 
139  ctx->hd_buf_filled += pkt->size;
140  if (++ctx->hd_buf_count < repeat){
141  ctx->pkt_offset = 0;
142  return 0;
143  }
144  ctx->data_type = IEC61937_EAC3;
145  ctx->pkt_offset = 24576;
146  ctx->out_buf = ctx->hd_buf[0];
147  ctx->out_bytes = ctx->hd_buf_filled;
148  ctx->length_code = ctx->hd_buf_filled;
149 
150  ctx->hd_buf_count = 0;
151  ctx->hd_buf_filled = 0;
152  return 0;
153 }
154 
155 /*
156  * DTS type IV (DTS-HD) can be transmitted with various frame repetition
157  * periods; longer repetition periods allow for longer packets and therefore
158  * higher bitrate. Longer repetition periods mean that the constant bitrate of
159  * the output IEC 61937 stream is higher.
160  * The repetition period is measured in IEC 60958 frames (4 bytes).
161  */
162  static int spdif_dts4_subtype(int period)
163 {
164  switch (period) {
165  case 512: return 0x0;
166  case 1024: return 0x1;
167  case 2048: return 0x2;
168  case 4096: return 0x3;
169  case 8192: return 0x4;
170  case 16384: return 0x5;
171  }
172  return -1;
173 }
174 
175  static int spdif_header_dts4(AVFormatContext *s, AVPacket *pkt, int core_size,
176  int sample_rate, int blocks)
177 {
178  IEC61937Context *ctx = s->priv_data;
179  static const char dtshd_start_code[10] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe };
180  int pkt_size = pkt->size;
181  int period;
182  int subtype;
183 
184  if (!core_size) {
185  av_log(s, AV_LOG_ERROR, "HD mode not supported for this format\n");
186  return AVERROR(EINVAL);
187  }
188 
189  if (!sample_rate) {
190  av_log(s, AV_LOG_ERROR, "Unknown DTS sample rate for HD\n");
191  return AVERROR_INVALIDDATA;
192  }
193 
194  period = ctx->dtshd_rate * (blocks << 5) / sample_rate;
195  subtype = spdif_dts4_subtype(period);
196 
197  if (subtype < 0) {
198  av_log(s, AV_LOG_ERROR, "Specified HD rate of %d Hz would require an "
199  "impossible repetition period of %d for the current DTS stream"
200  " (blocks = %d, sample rate = %d)\n", ctx->dtshd_rate, period,
201  blocks << 5, sample_rate);
202  return AVERROR(EINVAL);
203  }
204 
205  /* set pkt_offset and DTS IV subtype according to the requested output
206  * rate */
207  ctx->pkt_offset = period * 4;
208  ctx->data_type = IEC61937_DTSHD | subtype << 8;
209 
210  /* If the bitrate is too high for transmitting at the selected
211  * repetition period setting, strip DTS-HD until a good amount
212  * of consecutive non-overflowing HD frames have been observed.
213  * This generally only happens if the caller is cramming a Master
214  * Audio stream into 192kHz IEC 60958 (which may or may not fit). */
215  if (sizeof(dtshd_start_code) + 2 + pkt_size
216  > ctx->pkt_offset - BURST_HEADER_SIZE && core_size) {
217  if (!ctx->dtshd_skip)
218  av_log(s, AV_LOG_WARNING, "DTS-HD bitrate too high, "
219  "temporarily sending core only\n");
220  if (ctx->dtshd_fallback > 0)
221  ctx->dtshd_skip = sample_rate * ctx->dtshd_fallback / (blocks << 5);
222  else
223  /* skip permanently (dtshd_fallback == -1) or just once
224  * (dtshd_fallback == 0) */
225  ctx->dtshd_skip = 1;
226  }
227  if (ctx->dtshd_skip && core_size) {
228  pkt_size = core_size;
229  if (ctx->dtshd_fallback >= 0)
230  --ctx->dtshd_skip;
231  }
232 
233  ctx->out_bytes = sizeof(dtshd_start_code) + 2 + pkt_size;
234 
235  /* Align so that (length_code & 0xf) == 0x8. This is reportedly needed
236  * with some receivers, but the exact requirement is unconfirmed. */
237  ctx->length_code = FFALIGN(ctx->out_bytes + 0x8, 0x10) - 0x8;
238 
239  av_fast_malloc(&ctx->hd_buf[0], &ctx->hd_buf_size, ctx->out_bytes);
240  if (!ctx->hd_buf[0])
241  return AVERROR(ENOMEM);
242 
243  ctx->out_buf = ctx->hd_buf[0];
244 
245  memcpy(ctx->hd_buf[0], dtshd_start_code, sizeof(dtshd_start_code));
246  AV_WB16(ctx->hd_buf[0] + sizeof(dtshd_start_code), pkt_size);
247  memcpy(ctx->hd_buf[0] + sizeof(dtshd_start_code) + 2, pkt->data, pkt_size);
248 
249  return 0;
250 }
251 
252  static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt)
253 {
254  IEC61937Context *ctx = s->priv_data;
255  uint32_t syncword_dts = AV_RB32(pkt->data);
256  int blocks;
257  int sample_rate = 0;
258  int core_size = 0;
259 
260  if (pkt->size < 9)
261  return AVERROR_INVALIDDATA;
262 
263  switch (syncword_dts) {
264  case DCA_SYNCWORD_CORE_BE:
265  blocks = (AV_RB16(pkt->data + 4) >> 2) & 0x7f;
266  core_size = ((AV_RB24(pkt->data + 5) >> 4) & 0x3fff) + 1;
267  sample_rate = ff_dca_sample_rates[(pkt->data[8] >> 2) & 0x0f];
268  break;
269  case DCA_SYNCWORD_CORE_LE:
270  blocks = (AV_RL16(pkt->data + 4) >> 2) & 0x7f;
271  ctx->extra_bswap = 1;
272  break;
273  case DCA_SYNCWORD_CORE_14B_BE:
274  blocks =
275  (((pkt->data[5] & 0x07) << 4) | ((pkt->data[6] & 0x3f) >> 2));
276  break;
277  case DCA_SYNCWORD_CORE_14B_LE:
278  blocks =
279  (((pkt->data[4] & 0x07) << 4) | ((pkt->data[7] & 0x3f) >> 2));
280  ctx->extra_bswap = 1;
281  break;
282  case DCA_SYNCWORD_SUBSTREAM:
283  /* We only handle HD frames that are paired with core. However,
284  sometimes DTS-HD streams with core have a stray HD frame without
285  core in the beginning of the stream. */
286  av_log(s, AV_LOG_ERROR, "stray DTS-HD frame\n");
287  return AVERROR_INVALIDDATA;
288  default:
289  av_log(s, AV_LOG_ERROR, "bad DTS syncword 0x%"PRIx32"\n", syncword_dts);
290  return AVERROR_INVALIDDATA;
291  }
292  blocks++;
293 
294  if (ctx->dtshd_rate)
295  /* DTS type IV output requested */
296  return spdif_header_dts4(s, pkt, core_size, sample_rate, blocks);
297 
298  switch (blocks) {
299  case 512 >> 5: ctx->data_type = IEC61937_DTS1; break;
300  case 1024 >> 5: ctx->data_type = IEC61937_DTS2; break;
301  case 2048 >> 5: ctx->data_type = IEC61937_DTS3; break;
302  default:
303  av_log(s, AV_LOG_ERROR, "%i samples in DTS frame not supported\n",
304  blocks << 5);
305  return AVERROR(ENOSYS);
306  }
307 
308  /* discard extraneous data by default */
309  if (core_size && core_size < pkt->size) {
310  ctx->out_bytes = core_size;
311  ctx->length_code = core_size << 3;
312  }
313 
314  ctx->pkt_offset = blocks << 7;
315 
316  if (ctx->out_bytes == ctx->pkt_offset) {
317  /* The DTS stream fits exactly into the output stream, so skip the
318  * preamble as it would not fit in there. This is the case for dts
319  * discs and dts-in-wav. */
320  ctx->use_preamble = 0;
321  } else if (ctx->out_bytes > ctx->pkt_offset - BURST_HEADER_SIZE) {
322  avpriv_request_sample(s, "Unrecognized large DTS frame");
323  /* This will fail with a "bitrate too high" in the caller */
324  }
325 
326  return 0;
327 }
328 
329  static const enum IEC61937DataType mpeg_data_type[2][3] = {
330  // LAYER1 LAYER2 LAYER3
331  { IEC61937_MPEG2_LAYER1_LSF, IEC61937_MPEG2_LAYER2_LSF, IEC61937_MPEG2_LAYER3_LSF }, // MPEG-2 LSF
332  { IEC61937_MPEG1_LAYER1, IEC61937_MPEG1_LAYER23, IEC61937_MPEG1_LAYER23 }, // MPEG-1
333 };
334 
335  static int spdif_header_mpeg(AVFormatContext *s, AVPacket *pkt)
336 {
337  IEC61937Context *ctx = s->priv_data;
338  int version = (pkt->data[1] >> 3) & 3;
339  int layer = 3 - ((pkt->data[1] >> 1) & 3);
340  int extension = pkt->data[2] & 1;
341 
342  if (layer == 3 || version == 1) {
343  av_log(s, AV_LOG_ERROR, "Wrong MPEG file format\n");
344  return AVERROR_INVALIDDATA;
345  }
346  av_log(s, AV_LOG_DEBUG, "version: %i layer: %i extension: %i\n", version, layer, extension);
347  if (version == 2 && extension) {
348  ctx->data_type = IEC61937_MPEG2_EXT;
349  ctx->pkt_offset = 4608;
350  } else {
351  ctx->data_type = mpeg_data_type [version & 1][layer];
352  ctx->pkt_offset = spdif_mpeg_pkt_offset[version & 1][layer];
353  }
354  // TODO Data type dependent info (normal/karaoke, dynamic range control)
355  return 0;
356 }
357 
358  static int spdif_header_aac(AVFormatContext *s, AVPacket *pkt)
359 {
360  IEC61937Context *ctx = s->priv_data;
361  uint32_t samples;
362  uint8_t frames;
363  int ret;
364 
365  ret = av_adts_header_parse(pkt->data, &samples, &frames);
366  if (ret < 0) {
367  av_log(s, AV_LOG_ERROR, "Wrong AAC file format\n");
368  return ret;
369  }
370 
371  ctx->pkt_offset = samples << 2;
372  switch (frames) {
373  case 1:
374  ctx->data_type = IEC61937_MPEG2_AAC;
375  break;
376  case 2:
377  ctx->data_type = IEC61937_MPEG2_AAC_LSF_2048;
378  break;
379  case 4:
380  ctx->data_type = IEC61937_MPEG2_AAC_LSF_4096;
381  break;
382  default:
383  av_log(s, AV_LOG_ERROR,
384  "%"PRIu32" samples in AAC frame not supported\n", samples);
385  return AVERROR(EINVAL);
386  }
387  //TODO Data type dependent info (LC profile/SBR)
388  return 0;
389 }
390 
391 
392 /*
393  * It seems Dolby TrueHD frames have to be encapsulated in MAT frames before
394  * they can be encapsulated in IEC 61937.
395  */
396  #define MAT_PKT_OFFSET 61440
397  #define MAT_FRAME_SIZE 61424
398 
399  static const uint8_t mat_start_code[20] = {
400  0x07, 0x9E, 0x00, 0x03, 0x84, 0x01, 0x01, 0x01, 0x80, 0x00, 0x56, 0xA5, 0x3B, 0xF4, 0x81, 0x83,
401  0x49, 0x80, 0x77, 0xE0,
402 };
403  static const uint8_t mat_middle_code[12] = {
404  0xC3, 0xC1, 0x42, 0x49, 0x3B, 0xFA, 0x82, 0x83, 0x49, 0x80, 0x77, 0xE0,
405 };
406  static const uint8_t mat_end_code[16] = {
407  0xC3, 0xC2, 0xC0, 0xC4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x97, 0x11,
408 };
409 
410  #define MAT_CODE(position, data) { .pos = position, .code = data, .len = sizeof(data) }
411 
412 static const struct {
413   unsigned int pos;
414   unsigned int len;
415   const uint8_t *code;
416 } mat_codes[] = {
417  MAT_CODE(0, mat_start_code),
418  MAT_CODE(30708, mat_middle_code),
419  MAT_CODE(MAT_FRAME_SIZE - sizeof(mat_end_code), mat_end_code),
420 };
421 
422  static int spdif_header_truehd(AVFormatContext *s, AVPacket *pkt)
423 {
424  IEC61937Context *ctx = s->priv_data;
425  uint8_t *hd_buf = ctx->hd_buf[ctx->hd_buf_idx];
426  int ratebits;
427  int padding_remaining = 0;
428  uint16_t input_timing;
429  int total_frame_size = pkt->size;
430  const uint8_t *dataptr = pkt->data;
431  int data_remaining = pkt->size;
432  int have_pkt = 0;
433  int next_code_idx;
434 
435  if (pkt->size < 10)
436  return AVERROR_INVALIDDATA;
437 
438  if (AV_RB24(pkt->data + 4) == 0xf8726f) {
439  /* major sync unit, fetch sample rate */
440  if (pkt->data[7] == 0xba)
441  ratebits = pkt->data[8] >> 4;
442  else if (pkt->data[7] == 0xbb)
443  ratebits = pkt->data[9] >> 4;
444  else
445  return AVERROR_INVALIDDATA;
446 
447  ctx->truehd_samples_per_frame = 40 << (ratebits & 3);
448  av_log(s, AV_LOG_TRACE, "TrueHD samples per frame: %d\n",
449  ctx->truehd_samples_per_frame);
450  }
451 
452  if (!ctx->truehd_samples_per_frame)
453  return AVERROR_INVALIDDATA;
454 
455  input_timing = AV_RB16(pkt->data + 2);
456  if (ctx->truehd_prev_size) {
457  uint16_t delta_samples = input_timing - ctx->truehd_prev_time;
458  /*
459  * One multiple-of-48kHz frame is 1/1200 sec and the IEC 61937 rate
460  * is 768kHz = 768000*4 bytes/sec.
461  * The nominal space per frame is therefore
462  * (768000*4 bytes/sec) * (1/1200 sec) = 2560 bytes.
463  * For multiple-of-44.1kHz frames: 1/1102.5 sec, 705.6kHz, 2560 bytes.
464  *
465  * 2560 is divisible by truehd_samples_per_frame.
466  */
467  int delta_bytes = delta_samples * 2560 / ctx->truehd_samples_per_frame;
468 
469  /* padding needed before this frame */
470  padding_remaining = delta_bytes - ctx->truehd_prev_size;
471 
472  av_log(s, AV_LOG_TRACE, "delta_samples: %"PRIu16", delta_bytes: %d\n",
473  delta_samples, delta_bytes);
474 
475  /* sanity check */
476  if (padding_remaining < 0 || padding_remaining >= MAT_FRAME_SIZE / 2) {
477  avpriv_request_sample(s, "Unusual frame timing: %"PRIu16" => %"PRIu16", %d samples/frame",
478  ctx->truehd_prev_time, input_timing, ctx->truehd_samples_per_frame);
479  padding_remaining = 0;
480  }
481  }
482 
483  for (next_code_idx = 0; next_code_idx < FF_ARRAY_ELEMS(mat_codes); next_code_idx++)
484  if (ctx->hd_buf_filled <= mat_codes[next_code_idx].pos)
485  break;
486 
487  if (next_code_idx >= FF_ARRAY_ELEMS(mat_codes))
488  return AVERROR_BUG;
489 
490  while (padding_remaining || data_remaining ||
491  mat_codes[next_code_idx].pos == ctx->hd_buf_filled) {
492 
493  if (mat_codes[next_code_idx].pos == ctx->hd_buf_filled) {
494  /* time to insert MAT code */
495  int code_len = mat_codes[next_code_idx].len;
496  int code_len_remaining = code_len;
497  memcpy(hd_buf + mat_codes[next_code_idx].pos,
498  mat_codes[next_code_idx].code, code_len);
499  ctx->hd_buf_filled += code_len;
500 
501  next_code_idx++;
502  if (next_code_idx == FF_ARRAY_ELEMS(mat_codes)) {
503  next_code_idx = 0;
504 
505  /* this was the last code, move to the next MAT frame */
506  have_pkt = 1;
507  ctx->out_buf = hd_buf;
508  ctx->hd_buf_idx ^= 1;
509  hd_buf = ctx->hd_buf[ctx->hd_buf_idx];
510  ctx->hd_buf_filled = 0;
511 
512  /* inter-frame gap has to be counted as well, add it */
513  code_len_remaining += MAT_PKT_OFFSET - MAT_FRAME_SIZE;
514  }
515 
516  if (padding_remaining) {
517  /* consider the MAT code as padding */
518  int counted_as_padding = FFMIN(padding_remaining,
519  code_len_remaining);
520  padding_remaining -= counted_as_padding;
521  code_len_remaining -= counted_as_padding;
522  }
523  /* count the remainder of the code as part of frame size */
524  if (code_len_remaining)
525  total_frame_size += code_len_remaining;
526  }
527 
528  if (padding_remaining) {
529  int padding_to_insert = FFMIN(mat_codes[next_code_idx].pos - ctx->hd_buf_filled,
530  padding_remaining);
531 
532  memset(hd_buf + ctx->hd_buf_filled, 0, padding_to_insert);
533  ctx->hd_buf_filled += padding_to_insert;
534  padding_remaining -= padding_to_insert;
535 
536  if (padding_remaining)
537  continue; /* time to insert MAT code */
538  }
539 
540  if (data_remaining) {
541  int data_to_insert = FFMIN(mat_codes[next_code_idx].pos - ctx->hd_buf_filled,
542  data_remaining);
543 
544  memcpy(hd_buf + ctx->hd_buf_filled, dataptr, data_to_insert);
545  ctx->hd_buf_filled += data_to_insert;
546  dataptr += data_to_insert;
547  data_remaining -= data_to_insert;
548  }
549  }
550 
551  ctx->truehd_prev_size = total_frame_size;
552  ctx->truehd_prev_time = input_timing;
553 
554  av_log(s, AV_LOG_TRACE, "TrueHD frame inserted, total size %d, buffer position %d\n",
555  total_frame_size, ctx->hd_buf_filled);
556 
557  if (!have_pkt) {
558  ctx->pkt_offset = 0;
559  return 0;
560  }
561 
562  ctx->data_type = IEC61937_TRUEHD;
563  ctx->pkt_offset = MAT_PKT_OFFSET;
564  ctx->out_bytes = MAT_FRAME_SIZE;
565  ctx->length_code = MAT_FRAME_SIZE;
566  return 0;
567 }
568 
569  static int spdif_write_header(AVFormatContext *s)
570 {
571  IEC61937Context *ctx = s->priv_data;
572 
573  switch (s->streams[0]->codecpar->codec_id) {
574  case AV_CODEC_ID_AC3:
575  ctx->header_info = spdif_header_ac3;
576  break;
577  case AV_CODEC_ID_EAC3:
578  ctx->header_info = spdif_header_eac3;
579  break;
580  case AV_CODEC_ID_MP1:
581  case AV_CODEC_ID_MP2:
582  case AV_CODEC_ID_MP3:
583  ctx->header_info = spdif_header_mpeg;
584  break;
585  case AV_CODEC_ID_DTS:
586  ctx->header_info = spdif_header_dts;
587  break;
588  case AV_CODEC_ID_AAC:
589  ctx->header_info = spdif_header_aac;
590  break;
591  case AV_CODEC_ID_TRUEHD:
592  case AV_CODEC_ID_MLP:
593  ctx->header_info = spdif_header_truehd;
594  for (int i = 0; i < FF_ARRAY_ELEMS(ctx->hd_buf); i++) {
595  ctx->hd_buf[i] = av_malloc(MAT_FRAME_SIZE);
596  if (!ctx->hd_buf[i])
597  return AVERROR(ENOMEM);
598  }
599  break;
600  default:
601  avpriv_report_missing_feature(s, "Codec %d",
602  s->streams[0]->codecpar->codec_id);
603  return AVERROR_PATCHWELCOME;
604  }
605  return 0;
606 }
607 
608  static void spdif_deinit(AVFormatContext *s)
609 {
610  IEC61937Context *ctx = s->priv_data;
611  av_freep(&ctx->buffer);
612  for (int i = 0; i < FF_ARRAY_ELEMS(ctx->hd_buf); i++)
613  av_freep(&ctx->hd_buf[i]);
614 }
615 
616  static av_always_inline void spdif_put_16(IEC61937Context *ctx,
617  AVIOContext *pb, unsigned int val)
618 {
619  if (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)
620  avio_wb16(pb, val);
621  else
622  avio_wl16(pb, val);
623 }
624 
625  static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
626 {
627  IEC61937Context *ctx = s->priv_data;
628  int ret, padding;
629 
630  ctx->out_buf = pkt->data;
631  ctx->out_bytes = pkt->size;
632  ctx->length_code = FFALIGN(pkt->size, 2) << 3;
633  ctx->use_preamble = 1;
634  ctx->extra_bswap = 0;
635 
636  ret = ctx->header_info(s, pkt);
637  if (ret < 0)
638  return ret;
639  if (!ctx->pkt_offset)
640  return 0;
641 
642  padding = (ctx->pkt_offset - ctx->use_preamble * BURST_HEADER_SIZE - ctx->out_bytes) & ~1;
643  if (padding < 0) {
644  av_log(s, AV_LOG_ERROR, "bitrate is too high\n");
645  return AVERROR(EINVAL);
646  }
647 
648  if (ctx->use_preamble) {
649  spdif_put_16(ctx, s->pb, SYNCWORD1); //Pa
650  spdif_put_16(ctx, s->pb, SYNCWORD2); //Pb
651  spdif_put_16(ctx, s->pb, ctx->data_type); //Pc
652  spdif_put_16(ctx, s->pb, ctx->length_code);//Pd
653  }
654 
655  if (ctx->extra_bswap ^ (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)) {
656  avio_write(s->pb, ctx->out_buf, ctx->out_bytes & ~1);
657  } else {
658  av_fast_malloc(&ctx->buffer, &ctx->buffer_size, ctx->out_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
659  if (!ctx->buffer)
660  return AVERROR(ENOMEM);
661  ff_spdif_bswap_buf16((uint16_t *)ctx->buffer, (const uint16_t *)ctx->out_buf, ctx->out_bytes >> 1);
662  avio_write(s->pb, ctx->buffer, ctx->out_bytes & ~1);
663  }
664 
665  /* a final lone byte has to be MSB aligned */
666  if (ctx->out_bytes & 1)
667  spdif_put_16(ctx, s->pb, ctx->out_buf[ctx->out_bytes - 1] << 8);
668 
669  ffio_fill(s->pb, 0, padding);
670 
671  av_log(s, AV_LOG_DEBUG, "type=%x len=%i pkt_offset=%i\n",
672  ctx->data_type, ctx->out_bytes, ctx->pkt_offset);
673 
674  return 0;
675 }
676 
677  const FFOutputFormat ff_spdif_muxer = {
678  .p.name = "spdif",
679  .p.long_name = NULL_IF_CONFIG_SMALL("IEC 61937 (used on S/PDIF - IEC958)"),
680  .p.extensions = "spdif",
681  .priv_data_size = sizeof(IEC61937Context),
682  .p.audio_codec = AV_CODEC_ID_AC3,
683  .p.video_codec = AV_CODEC_ID_NONE,
684  .p.subtitle_codec = AV_CODEC_ID_NONE,
685  .write_header = spdif_write_header,
686  .write_packet = spdif_write_packet,
687  .deinit = spdif_deinit,
688  .p.flags = AVFMT_NOTIMESTAMPS,
689  .p.priv_class = &spdif_class,
690  .flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH,
691 };
IEC61937Context::truehd_samples_per_frame
int truehd_samples_per_frame
samples per frame for padding calculation
Definition: spdifenc.c:83
mpeg_data_type
static enum IEC61937DataType mpeg_data_type[2][3]
Definition: spdifenc.c:329
IEC61937Context::extra_bswap
int extra_bswap
extra bswap for payload (for LE DTS => standard BE DTS)
Definition: spdifenc.c:71
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
MAT_PKT_OFFSET
#define MAT_PKT_OFFSET
Definition: spdifenc.c:396
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:335
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:443
IEC61937DataType
IEC61937DataType
Definition: spdif.h:32
AVOutputFormat::name
const char * name
Definition: avformat.h:510
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:89
dca.h
spdif_header_aac
static int spdif_header_aac(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:358
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
spdif_write_packet
static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:625
IEC61937Context::truehd_prev_time
uint16_t truehd_prev_time
input_timing from the last frame
Definition: spdifenc.c:81
IEC61937Context::truehd_prev_size
int truehd_prev_size
previous frame size in bytes, including any MAT codes
Definition: spdifenc.c:82
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:63
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
mat_start_code
static const uint8_t mat_start_code[20]
Definition: spdifenc.c:399
AVPacket::data
uint8_t * data
Definition: packet.h:522
IEC61937Context::buffer_size
int buffer_size
size of allocated buffer
Definition: spdifenc.c:65
AVOption
AVOption.
Definition: opt.h:346
len
unsigned int len
Definition: spdifenc.c:414
spdif_header_truehd
static int spdif_header_truehd(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:422
IEC61937_MPEG2_LAYER1_LSF
@ IEC61937_MPEG2_LAYER1_LSF
MPEG-2, layer-1 low sampling frequency.
Definition: spdif.h:38
spdif_put_16
static av_always_inline void spdif_put_16(IEC61937Context *ctx, AVIOContext *pb, unsigned int val)
Definition: spdifenc.c:616
mat_codes
static const struct @348 mat_codes[]
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:484
sample_rate
sample_rate
Definition: ffmpeg_filter.c:409
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
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:30
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:436
spdif_class
static const AVClass spdif_class
Definition: spdifenc.c:104
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:78
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:441
spdif_header_dts4
static int spdif_header_dts4(AVFormatContext *s, AVPacket *pkt, int core_size, int sample_rate, int blocks)
Definition: spdifenc.c:175
SPDIF_FLAG_BIGENDIAN
#define SPDIF_FLAG_BIGENDIAN
Definition: spdifenc.c:88
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:495
IEC61937_MPEG2_EXT
@ IEC61937_MPEG2_EXT
MPEG-2 data with extension.
Definition: spdif.h:36
s
#define s(width, name)
Definition: cbs_vp9.c:198
IEC61937Context
Definition: spdifenc.c:59
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:440
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
code
const uint8_t * code
Definition: spdifenc.c:415
ff_dca_sample_rates
const uint32_t ff_dca_sample_rates[16]
Definition: dca_sample_rate_tab.h:29
IEC61937Context::data_type
enum IEC61937DataType data_type
burst info - reference to type of payload of the data-burst
Definition: spdifenc.c:61
dca_syncwords.h
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
IEC61937_AC3
@ IEC61937_AC3
AC-3 data.
Definition: spdif.h:33
ac3defs.h
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AC3_FRAME_SIZE
#define AC3_FRAME_SIZE
Definition: ac3defs.h:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
IEC61937Context::av_class
const AVClass * av_class
Definition: spdifenc.c:60
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:403
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:252
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
FFOutputFormat
Definition: mux.h:61
IEC61937Context::hd_buf_count
int hd_buf_count
number of frames in the hd audio buffer (eac3)
Definition: spdifenc.c:75
IEC61937_DTSHD
@ IEC61937_DTSHD
DTS HD data.
Definition: spdif.h:47
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:186
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:269
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:480
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
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:121
DCA_SYNCWORD_CORE_BE
#define DCA_SYNCWORD_CORE_BE
Definition: dca_syncwords.h:22
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
IEC61937Context::out_buf
const uint8_t * out_buf
pointer to the outgoing data before byte-swapping
Definition: spdifenc.c:67
AVPacket::size
int size
Definition: packet.h:523
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:106
IEC61937Context::header_info
int(* header_info)(AVFormatContext *s, AVPacket *pkt)
function, which generates codec dependent header information.
Definition: spdifenc.c:93
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:444
mat_end_code
static const uint8_t mat_end_code[16]
Definition: spdifenc.c:406
IEC61937Context::out_bytes
int out_bytes
amount of outgoing bytes
Definition: spdifenc.c:68
size
int size
Definition: twinvq_data.h:10344
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
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:200
IEC61937Context::length_code
int length_code
length code in bits or bytes, depending on data type
Definition: spdifenc.c:62
IEC61937Context::dtshd_rate
int dtshd_rate
Definition: spdifenc.c:86
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:569
version
version
Definition: libkvazaar.c:321
IEC61937Context::buffer
uint8_t * buffer
allocated buffer, used for swap bytes
Definition: spdifenc.c:64
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
avio_internal.h
FF_OFMT_FLAG_MAX_ONE_OF_EACH
#define FF_OFMT_FLAG_MAX_ONE_OF_EACH
If this flag is set, it indicates that for each codec type whose corresponding default codec (i....
Definition: mux.h:50
IEC61937Context::dtshd_skip
int dtshd_skip
counter used for skipping DTS-HD frames
Definition: spdifenc.c:79
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:70
IEC61937_MPEG1_LAYER1
@ IEC61937_MPEG1_LAYER1
MPEG-1 layer 1.
Definition: spdif.h:34
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
IEC61937_EAC3
@ IEC61937_EAC3
E-AC-3 data.
Definition: spdif.h:51
IEC61937Context::dtshd_fallback
int dtshd_fallback
Definition: spdifenc.c:87
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:71
adts_parser.h
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
SYNCWORD2
#define SYNCWORD2
Definition: spdif.h:29
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
IEC61937Context::hd_buf_size
int hd_buf_size
size of the hd audio buffer (eac3, dts4)
Definition: spdifenc.c:74
BURST_HEADER_SIZE
#define BURST_HEADER_SIZE
Definition: spdif.h:30
spdif_dts4_subtype
static int spdif_dts4_subtype(int period)
Definition: spdifenc.c:162
IEC61937_TRUEHD
@ IEC61937_TRUEHD
TrueHD data.
Definition: spdif.h:52
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
samples
Filter the word "frame" indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
IEC61937Context::hd_buf_filled
int hd_buf_filled
amount of bytes in the hd audio buffer (eac3, truehd)
Definition: spdifenc.c:76
MAT_CODE
#define MAT_CODE(position, data)
Definition: spdifenc.c:410
IEC61937Context::hd_buf
uint8_t * hd_buf[2]
allocated buffers to concatenate hd audio frames
Definition: spdifenc.c:73
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:36
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:499
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:555
spdif_header_ac3
static int spdif_header_ac3(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:111
mat_middle_code
static const uint8_t mat_middle_code[12]
Definition: spdifenc.c:403
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:234
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:442
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
ff_spdif_muxer
const FFOutputFormat ff_spdif_muxer
Definition: spdifenc.c:677
options
static const AVOption options[]
Definition: spdifenc.c:96
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:61
spdif_deinit
static void spdif_deinit(AVFormatContext *s)
Definition: spdifenc.c:608
MAT_FRAME_SIZE
#define MAT_FRAME_SIZE
Definition: spdifenc.c:397
IEC61937Context::hd_buf_idx
int hd_buf_idx
active hd buffer index (truehd)
Definition: spdifenc.c:77
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
int
int
Definition: ffmpeg_filter.c:409
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:482
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:469
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
mux.h
Generated on Thu Sep 26 2024 23:15:52 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /