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/ac3.h"
53 #include "libavcodec/adts_parser.h"
54 #include "libavcodec/dca.h"
56 #include "libavutil/opt.h"
57 
58 typedef struct IEC61937Context {
59  const AVClass *av_class;
60  enum IEC61937DataType data_type;///< burst info - reference to type of payload of the data-burst
61  int length_code; ///< length code in bits or bytes, depending on data type
62  int pkt_offset; ///< data burst repetition period in bytes
63  uint8_t *buffer; ///< allocated buffer, used for swap bytes
64  int buffer_size; ///< size of allocated buffer
65 
66  uint8_t *out_buf; ///< pointer to the outgoing data before byte-swapping
67  int out_bytes; ///< amount of outgoing bytes
68 
69  int use_preamble; ///< preamble enabled (disabled for exactly pre-padded DTS)
70  int extra_bswap; ///< extra bswap for payload (for LE DTS => standard BE DTS)
71 
72  uint8_t *hd_buf[2]; ///< allocated buffers to concatenate hd audio frames
73  int hd_buf_size; ///< size of the hd audio buffer (eac3, dts4)
74  int hd_buf_count; ///< number of frames in the hd audio buffer (eac3)
75  int hd_buf_filled; ///< amount of bytes in the hd audio buffer (eac3, truehd)
76  int hd_buf_idx; ///< active hd buffer index (truehd)
77 
78  int dtshd_skip; ///< counter used for skipping DTS-HD frames
79 
80  uint16_t truehd_prev_time; ///< input_timing from the last frame
81  int truehd_prev_size; ///< previous frame size in bytes, including any MAT codes
82  int truehd_samples_per_frame; ///< samples per frame for padding calculation
83 
84  /* AVOptions: */
87 #define SPDIF_FLAG_BIGENDIAN 0x01
89 
90  /// function, which generates codec dependent header information.
91  /// Sets data_type and pkt_offset, and length_code, out_bytes, out_buf if necessary
94 
95 static const AVOption options[] = {
96 { "spdif_flags", "IEC 61937 encapsulation flags", offsetof(IEC61937Context, spdif_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },
97 { "be", "output in big-endian format (for use as s16be)", 0, AV_OPT_TYPE_CONST, {.i64 = SPDIF_FLAG_BIGENDIAN}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },
98 { "dtshd_rate", "mux complete DTS frames in HD mode at the specified IEC958 rate (in Hz, default 0=disabled)", offsetof(IEC61937Context, dtshd_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 768000, AV_OPT_FLAG_ENCODING_PARAM },
99 { "dtshd_fallback_time", "min secs to strip HD for after an overflow (-1: till the end, default 60)", offsetof(IEC61937Context, dtshd_fallback), AV_OPT_TYPE_INT, {.i64 = 60}, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
100 { NULL },
101 };
102 
103 static const AVClass spdif_class = {
104  .class_name = "spdif",
105  .item_name = av_default_item_name,
106  .option = options,
107  .version = LIBAVUTIL_VERSION_INT,
108 };
109 
111 {
113  int bitstream_mode = pkt->data[5] & 0x7;
114 
115  ctx->data_type = IEC61937_AC3 | (bitstream_mode << 8);
116  ctx->pkt_offset = AC3_FRAME_SIZE << 2;
117  return 0;
118 }
119 
121 {
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 {
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 
252 {
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) {
264  blocks = (AV_RB16(pkt->data + 4) >> 2) & 0x7f;
265  core_size = ((AV_RB24(pkt->data + 5) >> 4) & 0x3fff) + 1;
266  sample_rate = avpriv_dca_sample_rates[(pkt->data[8] >> 2) & 0x0f];
267  break;
269  blocks = (AV_RL16(pkt->data + 4) >> 2) & 0x7f;
270  ctx->extra_bswap = 1;
271  break;
273  blocks =
274  (((pkt->data[5] & 0x07) << 4) | ((pkt->data[6] & 0x3f) >> 2));
275  break;
277  blocks =
278  (((pkt->data[4] & 0x07) << 4) | ((pkt->data[7] & 0x3f) >> 2));
279  ctx->extra_bswap = 1;
280  break;
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
331  { IEC61937_MPEG1_LAYER1, IEC61937_MPEG1_LAYER23, IEC61937_MPEG1_LAYER23 }, // MPEG-1
332 };
333 
335 {
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) {
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 
358 {
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:
374  break;
375  case 2:
377  break;
378  case 4:
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[] = {
417  MAT_CODE(30708, mat_middle_code),
419 };
420 
422 {
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",
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;
565  return 0;
566 }
567 
569 {
571 
572  switch (s->streams[0]->codecpar->codec_id) {
573  case AV_CODEC_ID_AC3:
575  break;
576  case AV_CODEC_ID_EAC3:
578  break;
579  case AV_CODEC_ID_MP1:
580  case AV_CODEC_ID_MP2:
581  case AV_CODEC_ID_MP3:
583  break;
584  case AV_CODEC_ID_DTS:
586  break;
587  case AV_CODEC_ID_AAC:
589  break;
590  case AV_CODEC_ID_TRUEHD:
591  case AV_CODEC_ID_MLP:
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 
608 {
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 
616  AVIOContext *pb, unsigned int val)
617 {
619  avio_wb16(pb, val);
620  else
621  avio_wl16(pb, val);
622 }
623 
625 {
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 {
658  if (!ctx->buffer)
659  return AVERROR(ENOMEM);
660  ff_spdif_bswap_buf16((uint16_t *)ctx->buffer, (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 
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,
685  .deinit = spdif_deinit,
687  .priv_class = &spdif_class,
688 };
MPEG-2 AAC ADTS half-rate low sampling frequency.
Definition: spdif.h:49
uint8_t * out_buf
pointer to the outgoing data before byte-swapping
Definition: spdifenc.c:66
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:729
int hd_buf_idx
active hd buffer index (truehd)
Definition: spdifenc.c:76
uint8_t * hd_buf[2]
allocated buffers to concatenate hd audio frames
Definition: spdifenc.c:72
#define NULL
Definition: coverity.c:32
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:455
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
version
Definition: libkvazaar.c:320
int truehd_prev_size
previous frame size in bytes, including any MAT codes
Definition: spdifenc.c:81
AVOption.
Definition: opt.h:248
int pkt_offset
data burst repetition period in bytes
Definition: spdifenc.c:62
static int spdif_header_mpeg(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:334
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
#define BURST_HEADER_SIZE
Definition: spdif.h:30
MPEG-2, layer-1 low sampling frequency.
Definition: spdif.h:38
static int spdif_dts4_subtype(int period)
Definition: spdifenc.c:161
#define avpriv_request_sample(...)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int size
Definition: packet.h:370
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
static const uint8_t mat_start_code[20]
Definition: spdifenc.c:398
IEC61937DataType
Definition: spdif.h:32
static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:624
#define FF_ARRAY_ELEMS(a)
int truehd_samples_per_frame
samples per frame for padding calculation
Definition: spdifenc.c:82
static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:251
void ff_spdif_bswap_buf16(uint16_t *dst, const uint16_t *src, int w)
Definition: spdif.c:26
AVPacket * pkt
Definition: movenc.c:59
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:91
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:91
if it could not because there are no more frames
static int spdif_header_eac3(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:120
static const uint8_t mat_middle_code[12]
Definition: spdifenc.c:402
int buffer_size
size of allocated buffer
Definition: spdifenc.c:64
Format I/O context.
Definition: avformat.h:1247
static void spdif_deinit(AVFormatContext *s)
Definition: spdifenc.c:607
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
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
static const AVClass spdif_class
Definition: spdifenc.c:103
MPEG-2 AAC ADTS.
Definition: spdif.h:37
uint8_t
#define av_malloc(s)
AVOptions.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
#define DCA_SYNCWORD_CORE_14B_BE
Definition: dca_syncwords.h:24
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:91
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1315
AVOutputFormat ff_spdif_muxer
Definition: spdifenc.c:676
uint8_t * data
Definition: packet.h:369
#define SPDIF_FLAG_BIGENDIAN
Definition: spdifenc.c:87
DTS type II (1024 samples)
Definition: spdif.h:42
ptrdiff_t size
Definition: opengl_enc.c:100
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:225
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
#define FFALIGN(x, a)
Definition: macros.h:48
TrueHD data.
Definition: spdif.h:52
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:278
#define DCA_SYNCWORD_CORE_BE
Definition: dca_syncwords.h:22
DTS HD data.
Definition: spdif.h:47
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
DTS type III (2048 samples)
Definition: spdif.h:43
const AVClass * av_class
Definition: spdifenc.c:59
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
int(* header_info)(AVFormatContext *s, AVPacket *pkt)
function, which generates codec dependent header information.
Definition: spdifenc.c:92
const uint8_t * code
Definition: spdifenc.c:413
unsigned int pos
Definition: spdifenc.c:412
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:425
MPEG-1 layer 2 or 3 data or MPEG-2 without extension.
Definition: spdif.h:35
MPEG-2, layer-3 low sampling frequency.
Definition: spdif.h:40
int hd_buf_count
number of frames in the hd audio buffer (eac3)
Definition: spdifenc.c:74
#define DCA_SYNCWORD_CORE_14B_LE
Definition: dca_syncwords.h:25
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
static const struct @285 mat_codes[]
MPEG-1 layer 1.
Definition: spdif.h:34
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:502
#define MAT_CODE(position, data)
Definition: spdifenc.c:409
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:211
#define FFMIN(a, b)
Definition: common.h:105
uint8_t * buffer
allocated buffer, used for swap bytes
Definition: spdifenc.c:63
int out_bytes
amount of outgoing bytes
Definition: spdifenc.c:67
const char * name
Definition: avformat.h:500
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:478
int dtshd_fallback
Definition: spdifenc.c:86
const uint32_t avpriv_dca_sample_rates[16]
Definition: dca.c:36
static av_always_inline void spdif_put_16(IEC61937Context *ctx, AVIOContext *pb, unsigned int val)
Definition: spdifenc.c:615
enum IEC61937DataType data_type
burst info - reference to type of payload of the data-burst
Definition: spdifenc.c:60
static enum IEC61937DataType mpeg_data_type[2][3]
Definition: spdifenc.c:328
#define SYNCWORD2
Definition: spdif.h:29
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
static const AVOption options[]
Definition: spdifenc.c:95
sample_rate
#define MAT_FRAME_SIZE
Definition: spdifenc.c:396
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:91
static int spdif_write_header(AVFormatContext *s)
Definition: spdifenc.c:568
AVIOContext * pb
I/O context.
Definition: avformat.h:1289
int use_preamble
preamble enabled (disabled for exactly pre-padded DTS)
Definition: spdifenc.c:69
#define DCA_SYNCWORD_CORE_LE
Definition: dca_syncwords.h:23
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
int hd_buf_filled
amount of bytes in the hd audio buffer (eac3, truehd)
Definition: spdifenc.c:75
Describe the class of an AVClass context structure.
Definition: log.h:67
int length_code
length code in bits or bytes, depending on data type
Definition: spdifenc.c:61
static int spdif_header_truehd(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:421
DTS type I (512 samples)
Definition: spdif.h:41
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:461
#define flags(name, subs,...)
Definition: cbs_av1.c:561
MPEG-2, layer-2 low sampling frequency.
Definition: spdif.h:39
static int spdif_header_aac(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:357
E-AC-3 data.
Definition: spdif.h:51
#define AC3_FRAME_SIZE
Definition: ac3.h:37
Main libavformat public API header.
int
unsigned int len
Definition: spdifenc.c:414
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
MPEG-2 data with extension.
Definition: spdif.h:36
static const uint8_t mat_end_code[16]
Definition: spdifenc.c:405
int dtshd_skip
counter used for skipping DTS-HD frames
Definition: spdifenc.c:78
int hd_buf_size
size of the hd audio buffer (eac3, dts4)
Definition: spdifenc.c:73
MPEG-2 AAC ADTS quarter-rate low sampling frequency.
Definition: spdif.h:50
static const uint16_t spdif_mpeg_pkt_offset[2][3]
Definition: spdif.h:55
#define SYNCWORD1
Definition: spdif.h:28
void * priv_data
Format private data.
Definition: avformat.h:1275
#define DCA_SYNCWORD_SUBSTREAM
Definition: dca_syncwords.h:32
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
static int spdif_header_ac3(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:110
AC-3 data.
Definition: spdif.h:33
Filter the word “frame” indicates either a video frame or a group of audio samples
static int spdif_header_dts4(AVFormatContext *s, AVPacket *pkt, int core_size, int sample_rate, int blocks)
Definition: spdifenc.c:174
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:45
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1049
uint16_t truehd_prev_time
input_timing from the last frame
Definition: spdifenc.c:80
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
int extra_bswap
extra bswap for payload (for LE DTS => standard BE DTS)
Definition: spdifenc.c:70
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:346
Common code between the AC-3 encoder and decoder.
#define MAT_PKT_OFFSET
Definition: spdifenc.c:395
int i
Definition: input.c:407
static uint8_t tmp[11]
Definition: aes_ctr.c:27