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

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