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

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