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     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 {
 177     IEC61937Context *ctx = s->priv_data;
 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
 251 static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt)
 252 {
 253     IEC61937Context *ctx = s->priv_data;
 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) {
 263     case DCA_SYNCWORD_CORE_BE:
 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;
 268     case DCA_SYNCWORD_CORE_LE:
 269         blocks = (AV_RL16(pkt->data + 4) >> 2) & 0x7f;
 270         ctx->extra_bswap = 1;
 271         break;
 272     case DCA_SYNCWORD_CORE_14B_BE:
 273         blocks =
 274             (((pkt->data[5] & 0x07) << 4) | ((pkt->data[6] & 0x3f) >> 2));
 275         break;
 276     case DCA_SYNCWORD_CORE_14B_LE:
 277         blocks =
 278             (((pkt->data[4] & 0x07) << 4) | ((pkt->data[7] & 0x3f) >> 2));
 279         ctx->extra_bswap = 1;
 280         break;
 281     case DCA_SYNCWORD_SUBSTREAM:
 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
 330     { IEC61937_MPEG2_LAYER1_LSF, IEC61937_MPEG2_LAYER2_LSF, IEC61937_MPEG2_LAYER3_LSF }, // MPEG-2 LSF
 331     { IEC61937_MPEG1_LAYER1,     IEC61937_MPEG1_LAYER23,    IEC61937_MPEG1_LAYER23 },    // MPEG-1
 332 };
 333
 334 static int spdif_header_mpeg(AVFormatContext *s, AVPacket *pkt)
 335 {
 336     IEC61937Context *ctx = s->priv_data;
 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) {
 347         ctx->data_type  = IEC61937_MPEG2_EXT;
 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
 357 static int spdif_header_aac(AVFormatContext *s, AVPacket *pkt)
 358 {
 359     IEC61937Context *ctx = s->priv_data;
 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:
 373         ctx->data_type = IEC61937_MPEG2_AAC;
 374         break;
 375     case 2:
 376         ctx->data_type = IEC61937_MPEG2_AAC_LSF_2048;
 377         break;
 378     case 4:
 379         ctx->data_type = IEC61937_MPEG2_AAC_LSF_4096;
 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[] = {
 416     MAT_CODE(0, mat_start_code),
 417     MAT_CODE(30708, mat_middle_code),
 418     MAT_CODE(MAT_FRAME_SIZE - sizeof(mat_end_code), mat_end_code),
 419 };
 420
 421 static int spdif_header_truehd(AVFormatContext *s, AVPacket *pkt)
 422 {
 423     IEC61937Context *ctx = s->priv_data;
 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",
 448                ctx->truehd_samples_per_frame);
 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;
 564     ctx->length_code = MAT_FRAME_SIZE;
 565     return 0;
 566 }
 567
 568 static int spdif_write_header(AVFormatContext *s)
 569 {
 570     IEC61937Context *ctx = s->priv_data;
 571
 572     switch (s->streams[0]->codecpar->codec_id) {
 573     case AV_CODEC_ID_AC3:
 574         ctx->header_info = spdif_header_ac3;
 575         break;
 576     case AV_CODEC_ID_EAC3:
 577         ctx->header_info = spdif_header_eac3;
 578         break;
 579     case AV_CODEC_ID_MP1:
 580     case AV_CODEC_ID_MP2:
 581     case AV_CODEC_ID_MP3:
 582         ctx->header_info = spdif_header_mpeg;
 583         break;
 584     case AV_CODEC_ID_DTS:
 585         ctx->header_info = spdif_header_dts;
 586         break;
 587     case AV_CODEC_ID_AAC:
 588         ctx->header_info = spdif_header_aac;
 589         break;
 590     case AV_CODEC_ID_TRUEHD:
 591     case AV_CODEC_ID_MLP:
 592         ctx->header_info = spdif_header_truehd;
 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
 607 static void spdif_deinit(AVFormatContext *s)
 608 {
 609     IEC61937Context *ctx = s->priv_data;
 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
 615 static av_always_inline void spdif_put_16(IEC61937Context *ctx,
 616                                           AVIOContext *pb, unsigned int val)
 617 {
 618     if (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)
 619         avio_wb16(pb, val);
 620     else
 621         avio_wl16(pb, val);
 622 }
 623
 624 static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 625 {
 626     IEC61937Context *ctx = s->priv_data;
 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 {
 657         av_fast_malloc(&ctx->buffer, &ctx->buffer_size, ctx->out_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
 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
 676 AVOutputFormat ff_spdif_muxer = {
 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,
 683     .write_header      = spdif_write_header,
 684     .write_packet      = spdif_write_packet,
 685     .deinit            = spdif_deinit,
 686     .flags             = AVFMT_NOTIMESTAMPS,
 687     .priv_class        = &spdif_class,
 688 };