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