FFmpeg: libavformat/spdifenc.c Source File

FFmpeg

[フレーム]

libavformat

spdifenc.c

Go to the documentation of this file.

1 /*

2 * IEC 61937 muxer

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 */

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 */

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 */

47 #include <inttypes.h>

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"

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

66 uint8_t *out_buf; ///< pointer to the outgoing data before byte-swapping

67 int out_bytes; ///< amount of outgoing bytes

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)

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

77 int dtshd_skip; ///< counter used for skipping DTS-HD frames

79 /* AVOptions: */

80 int dtshd_rate;

81 int dtshd_fallback;

82 #define SPDIF_FLAG_BIGENDIAN 0x01

83 int spdif_flags;

85 /// function, which generates codec dependent header information.

86 /// Sets data_type and pkt_offset, and length_code, out_bytes, out_buf if necessary

87 int (*header_info) (AVFormatContext *s, AVPacket *pkt);

88 } IEC61937Context;

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 };

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

105 static int spdif_header_ac3(AVFormatContext *s, AVPacket *pkt)

106 {

107 IEC61937Context *ctx = s->priv_data;

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

115 static int spdif_header_eac3(AVFormatContext *s, AVPacket *pkt)

116 {

117 IEC61937Context *ctx = s->priv_data;

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 {

170 IEC61937Context *ctx = s->priv_data;

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

244 static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt)

245 {

246 IEC61937Context *ctx = s->priv_data;

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) {

256 case DCA_SYNCWORD_CORE_BE:

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;

261 case DCA_SYNCWORD_CORE_LE:

262 blocks = (AV_RL16(pkt->data + 4) >> 2) & 0x7f;

263 ctx->extra_bswap = 1;

264 break;

265 case DCA_SYNCWORD_CORE_14B_BE:

266 blocks =

267 (((pkt->data[5] & 0x07) << 4) | ((pkt->data[6] & 0x3f) >> 2));

268 break;

269 case DCA_SYNCWORD_CORE_14B_LE:

270 blocks =

271 (((pkt->data[4] & 0x07) << 4) | ((pkt->data[7] & 0x3f) >> 2));

272 ctx->extra_bswap = 1;

273 break;

274 case DCA_SYNCWORD_SUBSTREAM:

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

323 { IEC61937_MPEG2_LAYER1_LSF, IEC61937_MPEG2_LAYER2_LSF, IEC61937_MPEG2_LAYER3_LSF }, // MPEG-2 LSF

324 { IEC61937_MPEG1_LAYER1, IEC61937_MPEG1_LAYER23, IEC61937_MPEG1_LAYER23 }, // MPEG-1

325 };

326

327 static int spdif_header_mpeg(AVFormatContext *s, AVPacket *pkt)

328 {

329 IEC61937Context *ctx = s->priv_data;

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) {

340 ctx->data_type = IEC61937_MPEG2_EXT;

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

350 static int spdif_header_aac(AVFormatContext *s, AVPacket *pkt)

351 {

352 IEC61937Context *ctx = s->priv_data;

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:

366 ctx->data_type = IEC61937_MPEG2_AAC;

367 break;

368 case 2:

369 ctx->data_type = IEC61937_MPEG2_AAC_LSF_2048;

370 break;

371 case 4:

372 ctx->data_type = IEC61937_MPEG2_AAC_LSF_4096;

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

397 static int spdif_header_truehd(AVFormatContext *s, AVPacket *pkt)

398 {

399 IEC61937Context *ctx = s->priv_data;

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;

411 memcpy(&ctx->hd_buf[12 * TRUEHD_FRAME_OFFSET - BURST_HEADER_SIZE + 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 memset(&ctx->hd_buf[ctx->hd_buf_count * TRUEHD_FRAME_OFFSET - BURST_HEADER_SIZE + mat_code_length + pkt->size],

426 0, TRUEHD_FRAME_OFFSET - pkt->size - mat_code_length);

427

428 if (++ctx->hd_buf_count < 24){

429 ctx->pkt_offset = 0;

430 return 0;

431 }

432 memcpy(&ctx->hd_buf[MAT_FRAME_SIZE - sizeof(mat_end_code)], mat_end_code, sizeof(mat_end_code));

433 ctx->hd_buf_count = 0;

434

435 ctx->data_type = IEC61937_TRUEHD;

436 ctx->pkt_offset = 61440;

437 ctx->out_buf = ctx->hd_buf;

438 ctx->out_bytes = MAT_FRAME_SIZE;

439 ctx->length_code = MAT_FRAME_SIZE;

440 return 0;

441 }

442

443 static int spdif_write_header(AVFormatContext *s)

444 {

445 IEC61937Context *ctx = s->priv_data;

446

447 switch (s->streams[0]->codecpar->codec_id) {

448 case AV_CODEC_ID_AC3:

449 ctx->header_info = spdif_header_ac3;

450 break;

451 case AV_CODEC_ID_EAC3:

452 ctx->header_info = spdif_header_eac3;

453 break;

454 case AV_CODEC_ID_MP1:

455 case AV_CODEC_ID_MP2:

456 case AV_CODEC_ID_MP3:

457 ctx->header_info = spdif_header_mpeg;

458 break;

459 case AV_CODEC_ID_DTS:

460 ctx->header_info = spdif_header_dts;

461 break;

462 case AV_CODEC_ID_AAC:

463 ctx->header_info = spdif_header_aac;

464 break;

465 case AV_CODEC_ID_TRUEHD:

466 case AV_CODEC_ID_MLP:

467 ctx->header_info = spdif_header_truehd;

468 ctx->hd_buf = av_malloc(MAT_FRAME_SIZE);

469 if (!ctx->hd_buf)

470 return AVERROR(ENOMEM);

471 break;

472 default:

473 avpriv_report_missing_feature(s, "Codec %d",

474 s->streams[0]->codecpar->codec_id);

475 return AVERROR_PATCHWELCOME;

476 }

477 return 0;

478 }

479

480 static int spdif_write_trailer(AVFormatContext *s)

481 {

482 IEC61937Context *ctx = s->priv_data;

483 av_freep(&ctx->buffer);

484 av_freep(&ctx->hd_buf);

485 return 0;

486 }

487

488 static av_always_inline void spdif_put_16(IEC61937Context *ctx,

489 AVIOContext *pb, unsigned int val)

490 {

491 if (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)

492 avio_wb16(pb, val);

493 else

494 avio_wl16(pb, val);

495 }

496

497 static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)

498 {

499 IEC61937Context *ctx = s->priv_data;

500 int ret, padding;

501

502 ctx->out_buf = pkt->data;

503 ctx->out_bytes = pkt->size;

504 ctx->length_code = FFALIGN(pkt->size, 2) << 3;

505 ctx->use_preamble = 1;

506 ctx->extra_bswap = 0;

507

508 ret = ctx->header_info(s, pkt);

509 if (ret < 0)

510 return ret;

511 if (!ctx->pkt_offset)

512 return 0;

513

514 padding = (ctx->pkt_offset - ctx->use_preamble * BURST_HEADER_SIZE - ctx->out_bytes) & ~1;

515 if (padding < 0) {

516 av_log(s, AV_LOG_ERROR, "bitrate is too high\n");

517 return AVERROR(EINVAL);

518 }

519

520 if (ctx->use_preamble) {

521 spdif_put_16(ctx, s->pb, SYNCWORD1); //Pa

522 spdif_put_16(ctx, s->pb, SYNCWORD2); //Pb

523 spdif_put_16(ctx, s->pb, ctx->data_type); //Pc

524 spdif_put_16(ctx, s->pb, ctx->length_code);//Pd

525 }

526

527 if (ctx->extra_bswap ^ (ctx->spdif_flags & SPDIF_FLAG_BIGENDIAN)) {

528 avio_write(s->pb, ctx->out_buf, ctx->out_bytes & ~1);

529 } else {

530 av_fast_malloc(&ctx->buffer, &ctx->buffer_size, ctx->out_bytes + AV_INPUT_BUFFER_PADDING_SIZE);

531 if (!ctx->buffer)

532 return AVERROR(ENOMEM);

533 ff_spdif_bswap_buf16((uint16_t *)ctx->buffer, (uint16_t *)ctx->out_buf, ctx->out_bytes >> 1);

534 avio_write(s->pb, ctx->buffer, ctx->out_bytes & ~1);

535 }

536

537 /* a final lone byte has to be MSB aligned */

538 if (ctx->out_bytes & 1)

539 spdif_put_16(ctx, s->pb, ctx->out_buf[ctx->out_bytes - 1] << 8);

540

541 ffio_fill(s->pb, 0, padding);

542

543 av_log(s, AV_LOG_DEBUG, "type=%x len=%i pkt_offset=%i\n",

544 ctx->data_type, ctx->out_bytes, ctx->pkt_offset);

545

546 return 0;

547 }

548

549 AVOutputFormat ff_spdif_muxer = {

550 .name = "spdif",

551 .long_name = NULL_IF_CONFIG_SMALL("IEC 61937 (used on S/PDIF - IEC958)"),

552 .extensions = "spdif",

553 .priv_data_size = sizeof(IEC61937Context),

554 .audio_codec = AV_CODEC_ID_AC3,

555 .video_codec = AV_CODEC_ID_NONE,

556 .write_header = spdif_write_header,

557 .write_packet = spdif_write_packet,

558 .write_trailer = spdif_write_trailer,

559 .flags = AVFMT_NOTIMESTAMPS,

560 .priv_class = &spdif_class,

561 };

IEC61937_MPEG2_AAC_LSF_2048

MPEG-2 AAC ADTS half-rate low sampling frequency.

Definition: spdif.h:49

IEC61937Context::out_buf

uint8_t * out_buf

pointer to the outgoing data before byte-swapping

Definition: spdifenc.c:66

write_packet

static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)

Definition: ffmpeg.c:679

NULL

#define NULL

Definition: coverity.c:32

val

const char const char void * val

Definition: avisynth_c.h:771

AV_CODEC_ID_MLP

Definition: avcodec.h:580

avio_wl16

void avio_wl16(AVIOContext *s, unsigned int val)

Definition: aviobuf.c:469

const char * s

Definition: avisynth_c.h:768

AVIOContext

Bytestream IO Context.

Definition: avio.h:161

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

spdif.h

AV_CODEC_ID_NONE

Definition: avcodec.h:216

AVOption

AVOption.

Definition: opt.h:246

IEC61937Context::pkt_offset

int pkt_offset

data burst repetition period in bytes

Definition: spdifenc.c:62

spdif_header_mpeg

static int spdif_header_mpeg(AVFormatContext *s, AVPacket *pkt)

Definition: spdifenc.c:327

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

BURST_HEADER_SIZE

#define BURST_HEADER_SIZE

Definition: spdif.h:30

AV_OPT_TYPE_INT

Definition: opt.h:223

IEC61937_MPEG2_LAYER1_LSF

MPEG-2, layer-1 low sampling frequency.

Definition: spdif.h:38

spdif_dts4_subtype

static int spdif_dts4_subtype(int period)

Definition: spdifenc.c:154

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: avcodec.h:3884

AVPacket::size

int size

Definition: avcodec.h:1431

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:191

AV_CODEC_ID_MP1

Definition: avcodec.h:593

IEC61937DataType

Definition: spdif.h:32

dca.h

spdif_write_packet

static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)

Definition: spdifenc.c:497

version

int version

Definition: avisynth_c.h:766

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

spdif_header_dts

static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt)

Definition: spdifenc.c:244

ff_spdif_bswap_buf16

void ff_spdif_bswap_buf16(uint16_t *dst, const uint16_t *src, int w)

Definition: spdif.c:26

AV_RB16

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

AV_RL16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16

Definition: bytestream.h:87

AV_OPT_TYPE_FLAGS

Definition: opt.h:222

spdif_header_eac3

static int spdif_header_eac3(AVFormatContext *s, AVPacket *pkt)

Definition: spdifenc.c:115

IEC61937Context::buffer_size

int buffer_size

size of allocated buffer

Definition: spdifenc.c:64

AVFormatContext

Format I/O context.

Definition: avformat.h:1342

AVClass::class_name

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

av_adts_header_parse

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

spdif_class

static const AVClass spdif_class

Definition: spdifenc.c:98

AV_OPT_TYPE_CONST

Definition: opt.h:232

avpriv_request_sample

void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

IEC61937_MPEG2_AAC

MPEG-2 AAC ADTS.

Definition: spdif.h:37

uint8_t

Definition: audio_convert.c:194

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

opt.h

AVOptions.

DCA_SYNCWORD_CORE_14B_BE

#define DCA_SYNCWORD_CORE_14B_BE

Definition: dca_syncwords.h:24

AV_CODEC_ID_AAC

Definition: avcodec.h:553

AV_RB32

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

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1410

avio_internal.h

ff_spdif_muxer

AVOutputFormat ff_spdif_muxer

Definition: spdifenc.c:549

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

flags

static int flags

Definition: log.c:55

MAT_MIDDLE_CODE_OFFSET

#define MAT_MIDDLE_CODE_OFFSET

Definition: spdifenc.c:395

SPDIF_FLAG_BIGENDIAN

#define SPDIF_FLAG_BIGENDIAN

Definition: spdifenc.c:82

IEC61937_DTS2

DTS type II (1024 samples)

Definition: spdif.h:42

size

ptrdiff_t size

Definition: opengl_enc.c:101

avio_write

void avio_write(AVIOContext *s, const unsigned char *buf, int size)

Definition: aviobuf.c:218

spdif_write_trailer

static int spdif_write_trailer(AVFormatContext *s)

Definition: spdifenc.c:480

AV_WB16

#define AV_WB16(p, v)

Definition: intreadwrite.h:405

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:48

IEC61937_TRUEHD

TrueHD data.

Definition: spdif.h:52

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

AV_OPT_FLAG_ENCODING_PARAM

#define AV_OPT_FLAG_ENCODING_PARAM

a generic parameter which can be set by the user for muxing or encoding

Definition: opt.h:276

DCA_SYNCWORD_CORE_BE

#define DCA_SYNCWORD_CORE_BE

Definition: dca_syncwords.h:22

IEC61937_DTSHD

DTS HD data.

Definition: spdif.h:47

AV_CODEC_ID_TRUEHD

Definition: avcodec.h:595

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

IEC61937_DTS3

DTS type III (2048 samples)

Definition: spdif.h:43

IEC61937Context::av_class

const AVClass * av_class

Definition: spdifenc.c:59

AVERROR

#define AVERROR(e)

Definition: error.h:43

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:186

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AV_CODEC_ID_DTS

Definition: avcodec.h:555

AV_CODEC_ID_MP3

preferred ID for decoding MPEG audio layer 1, 2 or 3

Definition: avcodec.h:552

IEC61937_MPEG1_LAYER23

MPEG-1 layer 2 or 3 data or MPEG-2 without extension.

Definition: spdif.h:35

IEC61937_MPEG2_LAYER3_LSF

MPEG-2, layer-3 low sampling frequency.

Definition: spdif.h:40

IEC61937Context::hd_buf_count

int hd_buf_count

number of frames in the hd audio buffer

Definition: spdifenc.c:74

DCA_SYNCWORD_CORE_14B_LE

#define DCA_SYNCWORD_CORE_14B_LE

Definition: dca_syncwords.h:25

IEC61937_MPEG1_LAYER1

MPEG-1 layer 1.

Definition: spdif.h:34

av_fast_malloc

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:488

ffio_fill

void ffio_fill(AVIOContext *s, int b, int count)

Definition: aviobuf.c:204

IEC61937Context::buffer

uint8_t * buffer

allocated buffer, used for swap bytes

Definition: spdifenc.c:63

IEC61937Context::out_bytes

int out_bytes

amount of outgoing bytes

Definition: spdifenc.c:67

IEC61937Context::header_info

int(* header_info)(AVFormatContext *s, AVPacket *pkt)

function, which generates codec dependent header information.

Definition: spdifenc.c:87

write_trailer

static int write_trailer(AVFormatContext *s1)

Definition: v4l2enc.c:94

AVOutputFormat::name

const char * name

Definition: avformat.h:507

dca_syncwords.h

ctx

AVFormatContext * ctx

Definition: movenc.c:48

TRUEHD_FRAME_OFFSET

#define TRUEHD_FRAME_OFFSET

Definition: spdifenc.c:394

av_fast_realloc

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:464

IEC61937Context::dtshd_fallback

int dtshd_fallback

Definition: spdifenc.c:81

frames

int frames

Definition: movenc.c:65

avpriv_dca_sample_rates

const uint32_t avpriv_dca_sample_rates[16]

Definition: dca.c:36

spdif_put_16

static av_always_inline void spdif_put_16(IEC61937Context *ctx, AVIOContext *pb, unsigned int val)

Definition: spdifenc.c:488

IEC61937Context::data_type

enum IEC61937DataType data_type

burst info - reference to type of payload of the data-burst

Definition: spdifenc.c:60

mpeg_data_type

static enum IEC61937DataType mpeg_data_type[2][3]

Definition: spdifenc.c:321

SYNCWORD2

#define SYNCWORD2

Definition: spdif.h:29

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

AVFMT_NOTIMESTAMPS

#define AVFMT_NOTIMESTAMPS

Format does not need / have any timestamps.

Definition: avformat.h:469

options

static const AVOption options[]

Definition: spdifenc.c:90

sample_rate

Definition: ffmpeg_filter.c:190

MAT_FRAME_SIZE

#define MAT_FRAME_SIZE

Definition: spdifenc.c:393

AV_RB24

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

spdif_write_header

static int spdif_write_header(AVFormatContext *s)

Definition: spdifenc.c:443

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1384

IEC61937Context::use_preamble

int use_preamble

preamble enabled (disabled for exactly pre-padded DTS)

Definition: spdifenc.c:69