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 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; ///< allocated buffer to concatenate hd audio frames
73  int hd_buf_size; ///< size of the hd audio buffer
74  int hd_buf_count; ///< number of frames in the hd audio buffer
75  int hd_buf_filled; ///< amount of bytes in the hd audio buffer
76 
77  int dtshd_skip; ///< counter used for skipping DTS-HD frames
78 
79  /* AVOptions: */
82 #define SPDIF_FLAG_BIGENDIAN 0x01
84 
85  /// function, which generates codec dependent header information.
86  /// Sets data_type and pkt_offset, and length_code, out_bytes, out_buf if necessary
89 
90 static const AVOption options[] = {
91 { "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" },
92 { "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" },
93 { "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 },
94 { "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 },
95 { NULL },
96 };
97 
98 static const AVClass spdif_class = {
99  .class_name = "spdif",
100  .item_name = av_default_item_name,
101  .option = options,
102  .version = LIBAVUTIL_VERSION_INT,
103 };
104 
106 {
108  int bitstream_mode = pkt->data[5] & 0x7;
109 
110  ctx->data_type = IEC61937_AC3 | (bitstream_mode << 8);
111  ctx->pkt_offset = AC3_FRAME_SIZE << 2;
112  return 0;
113 }
114 
116 {
118  static const uint8_t eac3_repeat[4] = {6, 3, 2, 1};
119  int repeat = 1;
120 
121  int bsid = pkt->data[5] >> 3;
122  if (bsid > 10 && (pkt->data[4] & 0xc0) != 0xc0) /* fscod */
123  repeat = eac3_repeat[(pkt->data[4] & 0x30) >> 4]; /* numblkscod */
124 
125  ctx->hd_buf = av_fast_realloc(ctx->hd_buf, &ctx->hd_buf_size, ctx->hd_buf_filled + pkt->size);
126  if (!ctx->hd_buf)
127  return AVERROR(ENOMEM);
128 
129  memcpy(&ctx->hd_buf[ctx->hd_buf_filled], pkt->data, pkt->size);
130 
131  ctx->hd_buf_filled += pkt->size;
132  if (++ctx->hd_buf_count < repeat){
133  ctx->pkt_offset = 0;
134  return 0;
135  }
136  ctx->data_type = IEC61937_EAC3;
137  ctx->pkt_offset = 24576;
138  ctx->out_buf = ctx->hd_buf;
139  ctx->out_bytes = ctx->hd_buf_filled;
140  ctx->length_code = ctx->hd_buf_filled;
141 
142  ctx->hd_buf_count = 0;
143  ctx->hd_buf_filled = 0;
144  return 0;
145 }
146 
147 /*
148  * DTS type IV (DTS-HD) can be transmitted with various frame repetition
149  * periods; longer repetition periods allow for longer packets and therefore
150  * higher bitrate. Longer repetition periods mean that the constant bitrate of
151  * the output IEC 61937 stream is higher.
152  * The repetition period is measured in IEC 60958 frames (4 bytes).
153  */
154 static int spdif_dts4_subtype(int period)
155 {
156  switch (period) {
157  case 512: return 0x0;
158  case 1024: return 0x1;
159  case 2048: return 0x2;
160  case 4096: return 0x3;
161  case 8192: return 0x4;
162  case 16384: return 0x5;
163  }
164  return -1;
165 }
166 
167 static int spdif_header_dts4(AVFormatContext *s, AVPacket *pkt, int core_size,
168  int sample_rate, int blocks)
169 {
171  static const char dtshd_start_code[10] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe };
172  int pkt_size = pkt->size;
173  int period;
174  int subtype;
175 
176  if (!core_size) {
177  av_log(s, AV_LOG_ERROR, "HD mode not supported for this format\n");
178  return AVERROR(EINVAL);
179  }
180 
181  if (!sample_rate) {
182  av_log(s, AV_LOG_ERROR, "Unknown DTS sample rate for HD\n");
183  return AVERROR_INVALIDDATA;
184  }
185 
186  period = ctx->dtshd_rate * (blocks << 5) / sample_rate;
187  subtype = spdif_dts4_subtype(period);
188 
189  if (subtype < 0) {
190  av_log(s, AV_LOG_ERROR, "Specified HD rate of %d Hz would require an "
191  "impossible repetition period of %d for the current DTS stream"
192  " (blocks = %d, sample rate = %d)\n", ctx->dtshd_rate, period,
193  blocks << 5, sample_rate);
194  return AVERROR(EINVAL);
195  }
196 
197  /* set pkt_offset and DTS IV subtype according to the requested output
198  * rate */
199  ctx->pkt_offset = period * 4;
200  ctx->data_type = IEC61937_DTSHD | subtype << 8;
201 
202  /* If the bitrate is too high for transmitting at the selected
203  * repetition period setting, strip DTS-HD until a good amount
204  * of consecutive non-overflowing HD frames have been observed.
205  * This generally only happens if the caller is cramming a Master
206  * Audio stream into 192kHz IEC 60958 (which may or may not fit). */
207  if (sizeof(dtshd_start_code) + 2 + pkt_size
208  > ctx->pkt_offset - BURST_HEADER_SIZE && core_size) {
209  if (!ctx->dtshd_skip)
210  av_log(s, AV_LOG_WARNING, "DTS-HD bitrate too high, "
211  "temporarily sending core only\n");
212  if (ctx->dtshd_fallback > 0)
213  ctx->dtshd_skip = sample_rate * ctx->dtshd_fallback / (blocks << 5);
214  else
215  /* skip permanently (dtshd_fallback == -1) or just once
216  * (dtshd_fallback == 0) */
217  ctx->dtshd_skip = 1;
218  }
219  if (ctx->dtshd_skip && core_size) {
220  pkt_size = core_size;
221  if (ctx->dtshd_fallback >= 0)
222  --ctx->dtshd_skip;
223  }
224 
225  ctx->out_bytes = sizeof(dtshd_start_code) + 2 + pkt_size;
226 
227  /* Align so that (length_code & 0xf) == 0x8. This is reportedly needed
228  * with some receivers, but the exact requirement is unconfirmed. */
229  ctx->length_code = FFALIGN(ctx->out_bytes + 0x8, 0x10) - 0x8;
230 
231  av_fast_malloc(&ctx->hd_buf, &ctx->hd_buf_size, ctx->out_bytes);
232  if (!ctx->hd_buf)
233  return AVERROR(ENOMEM);
234 
235  ctx->out_buf = ctx->hd_buf;
236 
237  memcpy(ctx->hd_buf, dtshd_start_code, sizeof(dtshd_start_code));
238  AV_WB16(ctx->hd_buf + sizeof(dtshd_start_code), pkt_size);
239  memcpy(ctx->hd_buf + sizeof(dtshd_start_code) + 2, pkt->data, pkt_size);
240 
241  return 0;
242 }
243 
245 {
247  uint32_t syncword_dts = AV_RB32(pkt->data);
248  int blocks;
249  int sample_rate = 0;
250  int core_size = 0;
251 
252  if (pkt->size < 9)
253  return AVERROR_INVALIDDATA;
254 
255  switch (syncword_dts) {
257  blocks = (AV_RB16(pkt->data + 4) >> 2) & 0x7f;
258  core_size = ((AV_RB24(pkt->data + 5) >> 4) & 0x3fff) + 1;
259  sample_rate = avpriv_dca_sample_rates[(pkt->data[8] >> 2) & 0x0f];
260  break;
262  blocks = (AV_RL16(pkt->data + 4) >> 2) & 0x7f;
263  ctx->extra_bswap = 1;
264  break;
266  blocks =
267  (((pkt->data[5] & 0x07) << 4) | ((pkt->data[6] & 0x3f) >> 2));
268  break;
270  blocks =
271  (((pkt->data[4] & 0x07) << 4) | ((pkt->data[7] & 0x3f) >> 2));
272  ctx->extra_bswap = 1;
273  break;
275  /* We only handle HD frames that are paired with core. However,
276  sometimes DTS-HD streams with core have a stray HD frame without
277  core in the beginning of the stream. */
278  av_log(s, AV_LOG_ERROR, "stray DTS-HD frame\n");
279  return AVERROR_INVALIDDATA;
280  default:
281  av_log(s, AV_LOG_ERROR, "bad DTS syncword 0x%"PRIx32"\n", syncword_dts);
282  return AVERROR_INVALIDDATA;
283  }
284  blocks++;
285 
286  if (ctx->dtshd_rate)
287  /* DTS type IV output requested */
288  return spdif_header_dts4(s, pkt, core_size, sample_rate, blocks);
289 
290  switch (blocks) {
291  case 512 >> 5: ctx->data_type = IEC61937_DTS1; break;
292  case 1024 >> 5: ctx->data_type = IEC61937_DTS2; break;
293  case 2048 >> 5: ctx->data_type = IEC61937_DTS3; break;
294  default:
295  av_log(s, AV_LOG_ERROR, "%i samples in DTS frame not supported\n",
296  blocks << 5);
297  return AVERROR(ENOSYS);
298  }
299 
300  /* discard extraneous data by default */
301  if (core_size && core_size < pkt->size) {
302  ctx->out_bytes = core_size;
303  ctx->length_code = core_size << 3;
304  }
305 
306  ctx->pkt_offset = blocks << 7;
307 
308  if (ctx->out_bytes == ctx->pkt_offset) {
309  /* The DTS stream fits exactly into the output stream, so skip the
310  * preamble as it would not fit in there. This is the case for dts
311  * discs and dts-in-wav. */
312  ctx->use_preamble = 0;
313  } else if (ctx->out_bytes > ctx->pkt_offset - BURST_HEADER_SIZE) {
314  avpriv_request_sample(s, "Unrecognized large DTS frame");
315  /* This will fail with a "bitrate too high" in the caller */
316  }
317 
318  return 0;
319 }
320 
321 static const enum IEC61937DataType mpeg_data_type[2][3] = {
322  // LAYER1 LAYER2 LAYER3
324  { IEC61937_MPEG1_LAYER1, IEC61937_MPEG1_LAYER23, IEC61937_MPEG1_LAYER23 }, // MPEG-1
325 };
326 
328 {
330  int version = (pkt->data[1] >> 3) & 3;
331  int layer = 3 - ((pkt->data[1] >> 1) & 3);
332  int extension = pkt->data[2] & 1;
333 
334  if (layer == 3 || version == 1) {
335  av_log(s, AV_LOG_ERROR, "Wrong MPEG file format\n");
336  return AVERROR_INVALIDDATA;
337  }
338  av_log(s, AV_LOG_DEBUG, "version: %i layer: %i extension: %i\n", version, layer, extension);
339  if (version == 2 && extension) {
341  ctx->pkt_offset = 4608;
342  } else {
343  ctx->data_type = mpeg_data_type [version & 1][layer];
344  ctx->pkt_offset = spdif_mpeg_pkt_offset[version & 1][layer];
345  }
346  // TODO Data type dependent info (normal/karaoke, dynamic range control)
347  return 0;
348 }
349 
351 {
353  uint32_t samples;
354  uint8_t frames;
355  int ret;
356 
357  ret = av_adts_header_parse(pkt->data, &samples, &frames);
358  if (ret < 0) {
359  av_log(s, AV_LOG_ERROR, "Wrong AAC file format\n");
360  return ret;
361  }
362 
363  ctx->pkt_offset = samples << 2;
364  switch (frames) {
365  case 1:
367  break;
368  case 2:
370  break;
371  case 4:
373  break;
374  default:
375  av_log(s, AV_LOG_ERROR,
376  "%"PRIu32" samples in AAC frame not supported\n", samples);
377  return AVERROR(EINVAL);
378  }
379  //TODO Data type dependent info (LC profile/SBR)
380  return 0;
381 }
382 
383 
384 /*
385  * It seems Dolby TrueHD frames have to be encapsulated in MAT frames before
386  * they can be encapsulated in IEC 61937.
387  * Here we encapsulate 24 TrueHD frames in a single MAT frame, padding them
388  * to achieve constant rate.
389  * The actual format of a MAT frame is unknown, but the below seems to work.
390  * However, it seems it is not actually necessary for the 24 TrueHD frames to
391  * be in an exact alignment with the MAT frame.
392  */
393 #define MAT_FRAME_SIZE 61424
394 #define TRUEHD_FRAME_OFFSET 2560
395 #define MAT_MIDDLE_CODE_OFFSET -4
396 
398 {
400  int mat_code_length = 0;
401  static const char mat_end_code[16] = { 0xC3, 0xC2, 0xC0, 0xC4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x97, 0x11 };
402 
403  if (!ctx->hd_buf_count) {
404  static const char mat_start_code[20] = { 0x07, 0x9E, 0x00, 0x03, 0x84, 0x01, 0x01, 0x01, 0x80, 0x00, 0x56, 0xA5, 0x3B, 0xF4, 0x81, 0x83, 0x49, 0x80, 0x77, 0xE0 };
405  mat_code_length = sizeof(mat_start_code) + BURST_HEADER_SIZE;
406  memcpy(ctx->hd_buf, mat_start_code, sizeof(mat_start_code));
407 
408  } else if (ctx->hd_buf_count == 12) {
409  static const char mat_middle_code[12] = { 0xC3, 0xC1, 0x42, 0x49, 0x3B, 0xFA, 0x82, 0x83, 0x49, 0x80, 0x77, 0xE0 };
410  mat_code_length = sizeof(mat_middle_code) + MAT_MIDDLE_CODE_OFFSET;
412  mat_middle_code, sizeof(mat_middle_code));
413  }
414 
415  if (pkt->size > TRUEHD_FRAME_OFFSET - mat_code_length) {
416  /* if such frames exist, we'd need some more complex logic to
417  * distribute the TrueHD frames in the MAT frame */
418  avpriv_request_sample(s, "Too large TrueHD frame of %d bytes",
419  pkt->size);
420  return AVERROR_PATCHWELCOME;
421  }
422 
423  memcpy(&ctx->hd_buf[ctx->hd_buf_count * TRUEHD_FRAME_OFFSET - BURST_HEADER_SIZE + mat_code_length],
424  pkt->data, pkt->size);
425  if (ctx->hd_buf_count < 23) {
426  memset(&ctx->hd_buf[ctx->hd_buf_count * TRUEHD_FRAME_OFFSET - BURST_HEADER_SIZE + mat_code_length + pkt->size],
427  0, TRUEHD_FRAME_OFFSET - pkt->size - mat_code_length);
428  } else {
429  size_t padding = MAT_FRAME_SIZE - (ctx->hd_buf_count * TRUEHD_FRAME_OFFSET - BURST_HEADER_SIZE + pkt->size);
430  memset(&ctx->hd_buf[MAT_FRAME_SIZE - padding], 0, padding);
431  }
432 
433  if (++ctx->hd_buf_count < 24){
434  ctx->pkt_offset = 0;
435  return 0;
436  }
437  memcpy(&ctx->hd_buf[MAT_FRAME_SIZE - sizeof(mat_end_code)], mat_end_code, sizeof(mat_end_code));
438  ctx->hd_buf_count = 0;
439 
440  ctx->data_type = IEC61937_TRUEHD;
441  ctx->pkt_offset = 61440;
442  ctx->out_buf = ctx->hd_buf;
443  ctx->out_bytes = MAT_FRAME_SIZE;
445  return 0;
446 }
447 
449 {
451 
452  switch (s->streams[0]->codecpar->codec_id) {
453  case AV_CODEC_ID_AC3:
455  break;
456  case AV_CODEC_ID_EAC3:
458  break;
459  case AV_CODEC_ID_MP1:
460  case AV_CODEC_ID_MP2:
461  case AV_CODEC_ID_MP3:
463  break;
464  case AV_CODEC_ID_DTS:
466  break;
467  case AV_CODEC_ID_AAC:
469  break;
470  case AV_CODEC_ID_TRUEHD:
471  case AV_CODEC_ID_MLP:
474  if (!ctx->hd_buf)
475  return AVERROR(ENOMEM);
476  break;
477  default:
478  avpriv_report_missing_feature(s, "Codec %d",
479  s->streams[0]->codecpar->codec_id);
480  return AVERROR_PATCHWELCOME;
481  }
482  return 0;
483 }
484 
486 {
488  av_freep(&ctx->buffer);
489  av_freep(&ctx->hd_buf);
490  return 0;
491 }
492 
494  AVIOContext *pb, unsigned int val)
495 {
497  avio_wb16(pb, val);
498  else
499  avio_wl16(pb, val);
500 }
501 
503 {
505  int ret, padding;
506 
507  ctx->out_buf = pkt->data;
508  ctx->out_bytes = pkt->size;
509  ctx->length_code = FFALIGN(pkt->size, 2) << 3;
510  ctx->use_preamble = 1;
511  ctx->extra_bswap = 0;
512 
513  ret = ctx->header_info(s, pkt);
514  if (ret < 0)
515  return ret;
516  if (!ctx->pkt_offset)
517  return 0;
518 
519  padding = (ctx->pkt_offset - ctx->use_preamble * BURST_HEADER_SIZE - ctx->out_bytes) & ~1;
520  if (padding < 0) {
521  av_log(s, AV_LOG_ERROR, "bitrate is too high\n");
522  return AVERROR(EINVAL);
523  }
524 
525  if (ctx->use_preamble) {
526  spdif_put_16(ctx, s->pb, SYNCWORD1); //Pa
527  spdif_put_16(ctx, s->pb, SYNCWORD2); //Pb
528  spdif_put_16(ctx, s->pb, ctx->data_type); //Pc
529  spdif_put_16(ctx, s->pb, ctx->length_code);//Pd
530  }
531 
532  if (ctx->extra_bswap ^ (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)) {
533  avio_write(s->pb, ctx->out_buf, ctx->out_bytes & ~1);
534  } else {
536  if (!ctx->buffer)
537  return AVERROR(ENOMEM);
538  ff_spdif_bswap_buf16((uint16_t *)ctx->buffer, (uint16_t *)ctx->out_buf, ctx->out_bytes >> 1);
539  avio_write(s->pb, ctx->buffer, ctx->out_bytes & ~1);
540  }
541 
542  /* a final lone byte has to be MSB aligned */
543  if (ctx->out_bytes & 1)
544  spdif_put_16(ctx, s->pb, ctx->out_buf[ctx->out_bytes - 1] << 8);
545 
546  ffio_fill(s->pb, 0, padding);
547 
548  av_log(s, AV_LOG_DEBUG, "type=%x len=%i pkt_offset=%i\n",
549  ctx->data_type, ctx->out_bytes, ctx->pkt_offset);
550 
551  return 0;
552 }
553 
555  .name = "spdif",
556  .long_name = NULL_IF_CONFIG_SMALL("IEC 61937 (used on S/PDIF - IEC958)"),
557  .extensions = "spdif",
558  .priv_data_size = sizeof(IEC61937Context),
559  .audio_codec = AV_CODEC_ID_AC3,
560  .video_codec = AV_CODEC_ID_NONE,
565  .priv_class = &spdif_class,
566 };
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:690
#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:472
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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:327
#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:154
#define avpriv_request_sample(...)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
int size
Definition: avcodec.h:1481
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
IEC61937DataType
Definition: spdif.h:32
static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:502
int version
Definition: avisynth_c.h:858
static AVPacket pkt
static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:244
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:115
int buffer_size
size of allocated buffer
Definition: spdifenc.c:64
Format I/O context.
Definition: avformat.h:1358
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:98
MPEG-2 AAC ADTS.
Definition: spdif.h:37
uint8_t
#define av_malloc(s)
AVOptions.
#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:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
AVOutputFormat ff_spdif_muxer
Definition: spdifenc.c:554
uint8_t * data
Definition: avcodec.h:1480
#define MAT_MIDDLE_CODE_OFFSET
Definition: spdifenc.c:395
#define SPDIF_FLAG_BIGENDIAN
Definition: spdifenc.c:82
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:218
static int spdif_write_trailer(AVFormatContext *s)
Definition: spdifenc.c:485
#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 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:87
#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:566
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
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
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:204
uint8_t * buffer
allocated buffer, used for swap bytes
Definition: spdifenc.c:63
int out_bytes
amount of outgoing bytes
Definition: spdifenc.c:67
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
const char * name
Definition: avformat.h:505
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
#define TRUEHD_FRAME_OFFSET
Definition: spdifenc.c:394
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:81
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:493
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:321
#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:467
static const AVOption options[]
Definition: spdifenc.c:90
sample_rate
#define MAT_FRAME_SIZE
Definition: spdifenc.c:393
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:448
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
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
int hd_buf_filled
amount of bytes in the hd audio buffer
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:397
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:478
#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:350
E-AC-3 data.
Definition: spdif.h:51
#define AC3_FRAME_SIZE
Definition: ac3.h:38
Main libavformat public API header.
int
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
MPEG-2 data with extension.
Definition: spdif.h:36
int dtshd_skip
counter used for skipping DTS-HD frames
Definition: spdifenc.c:77
int hd_buf_size
size of the hd audio buffer
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:1386
#define DCA_SYNCWORD_SUBSTREAM
Definition: dca_syncwords.h:32
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:349
static int spdif_header_ac3(AVFormatContext *s, AVPacket *pkt)
Definition: spdifenc.c:105
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:167
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
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:1457
uint8_t * hd_buf
allocated buffer to concatenate hd audio frames
Definition: spdifenc.c:72
Common code between the AC-3 encoder and decoder.