git.sesse.net Git - ffmpeg/blob - libavformat/spdifenc.c

   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"
  55 #include "libavcodec/dca_syncwords.h"
  56 #include "libavutil/opt.h"
  57
  58 typedef struct IEC61937Context {
  59     const AVClass *av_class;
  60     enum IEC61937DataType data_type;///< burst info - reference to type of payload of the data-burst
  61     int length_code;                ///< length code in bits or bytes, depending on data type
  62     int pkt_offset;                 ///< data burst repetition period in bytes
  63     uint8_t *buffer;                ///< allocated buffer, used for swap bytes
  64     int buffer_size;                ///< size of allocated buffer
  65
  66     uint8_t *out_buf;               ///< pointer to the outgoing data before byte-swapping
  67     int out_bytes;                  ///< amount of outgoing bytes
  68
  69     int use_preamble;               ///< preamble enabled (disabled for exactly pre-padded DTS)
  70     int extra_bswap;                ///< extra bswap for payload (for LE DTS => standard BE DTS)
  71
  72     uint8_t *hd_buf[2];             ///< allocated buffers to concatenate hd audio frames
  73     int hd_buf_size;                ///< size of the hd audio buffer (eac3, dts4)
  74     int hd_buf_count;               ///< number of frames in the hd audio buffer (eac3)
  75     int hd_buf_filled;              ///< amount of bytes in the hd audio buffer (eac3, truehd)
  76     int hd_buf_idx;                 ///< active hd buffer index (truehd)
  77
  78     int dtshd_skip;                 ///< counter used for skipping DTS-HD frames
  79
  80     uint16_t truehd_prev_time;      ///< input_timing from the last frame
  81     int truehd_prev_size;           ///< previous frame size in bytes, including any MAT codes
  82     int truehd_samples_per_frame;   ///< samples per frame for padding calculation
  83
  84     /* AVOptions: */
  85     int dtshd_rate;
  86     int dtshd_fallback;
  87 #define SPDIF_FLAG_BIGENDIAN    0x01
  88     int spdif_flags;
  89
  90     /// function, which generates codec dependent header information.
  91     /// Sets data_type and pkt_offset, and length_code, out_bytes, out_buf if necessary
  92     int (*header_info) (AVFormatContext *s, AVPacket *pkt);
  93 } IEC61937Context;
  94
  95 static const AVOption options[] = {
  96 { "spdif_flags", "IEC 61937 encapsulation flags", offsetof(IEC61937Context, spdif_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },
  97 { "be", "output in big-endian format (for use as s16be)", 0, AV_OPT_TYPE_CONST, {.i64 = SPDIF_FLAG_BIGENDIAN},  0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },
  98 { "dtshd_rate", "mux complete DTS frames in HD mode at the specified IEC958 rate (in Hz, default 0=disabled)", offsetof(IEC61937Context, dtshd_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 768000, AV_OPT_FLAG_ENCODING_PARAM },
  99 { "dtshd_fallback_time", "min secs to strip HD for after an overflow (-1: till the end, default 60)", offsetof(IEC61937Context, dtshd_fallback), AV_OPT_TYPE_INT, {.i64 = 60}, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
 100 { NULL },
 101 };
 102
 103 static const AVClass spdif_class = {
 104     .class_name     = "spdif",
 105     .item_name      = av_default_item_name,
 106     .option         = options,
 107     .version        = LIBAVUTIL_VERSION_INT,
 108 };
 109
 110 static int spdif_header_ac3(AVFormatContext *s, AVPacket *pkt)
 111 {
 112     IEC61937Context *ctx = s->priv_data;
 113     int bitstream_mode = pkt->data[5] & 0x7;
 114
 115     ctx->data_type  = IEC61937_AC3 | (bitstream_mode << 8);
 116     ctx->pkt_offset = AC3_FRAME_SIZE << 2;
 117     return 0;
 118 }
 119
 120 static int spdif_header_eac3(AVFormatContext *s, AVPacket *pkt)
 121 {
 122     IEC61937Context *ctx = s->priv_data;
 123     static const uint8_t eac3_repeat[4] = {6, 3, 2, 1};
 124     int repeat = 1;
 125
 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 {
 175     IEC61937Context *ctx = s->priv_data;
 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
 249 static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt)
 250 {
 251     IEC61937Context *ctx = s->priv_data;
 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) {
 261     case DCA_SYNCWORD_CORE_BE:
 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;
 266     case DCA_SYNCWORD_CORE_LE:
 267         blocks = (AV_RL16(pkt->data + 4) >> 2) & 0x7f;
 268         ctx->extra_bswap = 1;
 269         break;
 270     case DCA_SYNCWORD_CORE_14B_BE:
 271         blocks =
 272             (((pkt->data[5] & 0x07) << 4) | ((pkt->data[6] & 0x3f) >> 2));
 273         break;
 274     case DCA_SYNCWORD_CORE_14B_LE:
 275         blocks =
 276             (((pkt->data[4] & 0x07) << 4) | ((pkt->data[7] & 0x3f) >> 2));
 277         ctx->extra_bswap = 1;
 278         break;
 279     case DCA_SYNCWORD_SUBSTREAM:
 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
 328     { IEC61937_MPEG2_LAYER1_LSF, IEC61937_MPEG2_LAYER2_LSF, IEC61937_MPEG2_LAYER3_LSF }, // MPEG-2 LSF
 329     { IEC61937_MPEG1_LAYER1,     IEC61937_MPEG1_LAYER23,    IEC61937_MPEG1_LAYER23 },    // MPEG-1
 330 };
 331
 332 static int spdif_header_mpeg(AVFormatContext *s, AVPacket *pkt)
 333 {
 334     IEC61937Context *ctx = s->priv_data;
 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) {
 345         ctx->data_type  = IEC61937_MPEG2_EXT;
 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
 355 static int spdif_header_aac(AVFormatContext *s, AVPacket *pkt)
 356 {
 357     IEC61937Context *ctx = s->priv_data;
 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:
 371         ctx->data_type = IEC61937_MPEG2_AAC;
 372         break;
 373     case 2:
 374         ctx->data_type = IEC61937_MPEG2_AAC_LSF_2048;
 375         break;
 376     case 4:
 377         ctx->data_type = IEC61937_MPEG2_AAC_LSF_4096;
 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[] = {
 414     MAT_CODE(0, mat_start_code),
 415     MAT_CODE(30708, mat_middle_code),
 416     MAT_CODE(MAT_FRAME_SIZE - sizeof(mat_end_code), mat_end_code),
 417 };
 418
 419 static int spdif_header_truehd(AVFormatContext *s, AVPacket *pkt)
 420 {
 421     IEC61937Context *ctx = s->priv_data;
 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",
 446                ctx->truehd_samples_per_frame);
 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;
 562     ctx->length_code = MAT_FRAME_SIZE;
 563     return 0;
 564 }
 565
 566 static int spdif_write_header(AVFormatContext *s)
 567 {
 568     IEC61937Context *ctx = s->priv_data;
 569
 570     switch (s->streams[0]->codecpar->codec_id) {
 571     case AV_CODEC_ID_AC3:
 572         ctx->header_info = spdif_header_ac3;
 573         break;
 574     case AV_CODEC_ID_EAC3:
 575         ctx->header_info = spdif_header_eac3;
 576         break;
 577     case AV_CODEC_ID_MP1:
 578     case AV_CODEC_ID_MP2:
 579     case AV_CODEC_ID_MP3:
 580         ctx->header_info = spdif_header_mpeg;
 581         break;
 582     case AV_CODEC_ID_DTS:
 583         ctx->header_info = spdif_header_dts;
 584         break;
 585     case AV_CODEC_ID_AAC:
 586         ctx->header_info = spdif_header_aac;
 587         break;
 588     case AV_CODEC_ID_TRUEHD:
 589     case AV_CODEC_ID_MLP:
 590         ctx->header_info = spdif_header_truehd;
 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
 605 static void spdif_deinit(AVFormatContext *s)
 606 {
 607     IEC61937Context *ctx = s->priv_data;
 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
 613 static av_always_inline void spdif_put_16(IEC61937Context *ctx,
 614                                           AVIOContext *pb, unsigned int val)
 615 {
 616     if (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)
 617         avio_wb16(pb, val);
 618     else
 619         avio_wl16(pb, val);
 620 }
 621
 622 static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 623 {
 624     IEC61937Context *ctx = s->priv_data;
 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 {
 655         av_fast_malloc(&ctx->buffer, &ctx->buffer_size, ctx->out_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
 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
 674 AVOutputFormat ff_spdif_muxer = {
 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,
 681     .write_header      = spdif_write_header,
 682     .write_packet      = spdif_write_packet,
 683     .deinit            = spdif_deinit,
 684     .flags             = AVFMT_NOTIMESTAMPS,
 685     .priv_class        = &spdif_class,
 686 };