blob: b47ec123e8b6a006f794204deba69e814c10c622
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/dca.h" |
54 | #include "libavcodec/dca_syncwords.h" |
55 | #include "libavcodec/aacadtsdec.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: */ |
80 | int dtshd_rate; |
81 | int dtshd_fallback; |
82 | #define SPDIF_FLAG_BIGENDIAN 0x01 |
83 | int spdif_flags; |
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 |
87 | int (*header_info) (AVFormatContext *s, AVPacket *pkt); |
88 | } IEC61937Context; |
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 | |
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 | if ((pkt->data[4] & 0xc0) != 0xc0) /* fscod */ |
122 | repeat = eac3_repeat[(pkt->data[4] & 0x30) >> 4]; /* numblkscod */ |
123 | |
124 | ctx->hd_buf = av_fast_realloc(ctx->hd_buf, &ctx->hd_buf_size, ctx->hd_buf_filled + pkt->size); |
125 | if (!ctx->hd_buf) |
126 | return AVERROR(ENOMEM); |
127 | |
128 | memcpy(&ctx->hd_buf[ctx->hd_buf_filled], pkt->data, pkt->size); |
129 | |
130 | ctx->hd_buf_filled += pkt->size; |
131 | if (++ctx->hd_buf_count < repeat){ |
132 | ctx->pkt_offset = 0; |
133 | return 0; |
134 | } |
135 | ctx->data_type = IEC61937_EAC3; |
136 | ctx->pkt_offset = 24576; |
137 | ctx->out_buf = ctx->hd_buf; |
138 | ctx->out_bytes = ctx->hd_buf_filled; |
139 | ctx->length_code = ctx->hd_buf_filled; |
140 | |
141 | ctx->hd_buf_count = 0; |
142 | ctx->hd_buf_filled = 0; |
143 | return 0; |
144 | } |
145 | |
146 | /* |
147 | * DTS type IV (DTS-HD) can be transmitted with various frame repetition |
148 | * periods; longer repetition periods allow for longer packets and therefore |
149 | * higher bitrate. Longer repetition periods mean that the constant bitrate of |
150 | * the output IEC 61937 stream is higher. |
151 | * The repetition period is measured in IEC 60958 frames (4 bytes). |
152 | */ |
153 | static int spdif_dts4_subtype(int period) |
154 | { |
155 | switch (period) { |
156 | case 512: return 0x0; |
157 | case 1024: return 0x1; |
158 | case 2048: return 0x2; |
159 | case 4096: return 0x3; |
160 | case 8192: return 0x4; |
161 | case 16384: return 0x5; |
162 | } |
163 | return -1; |
164 | } |
165 | |
166 | static int spdif_header_dts4(AVFormatContext *s, AVPacket *pkt, int core_size, |
167 | int sample_rate, int blocks) |
168 | { |
169 | IEC61937Context *ctx = s->priv_data; |
170 | static const char dtshd_start_code[10] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe }; |
171 | int pkt_size = pkt->size; |
172 | int period; |
173 | int subtype; |
174 | |
175 | if (!core_size) { |
176 | av_log(s, AV_LOG_ERROR, "HD mode not supported for this format\n"); |
177 | return AVERROR(EINVAL); |
178 | } |
179 | |
180 | if (!sample_rate) { |
181 | av_log(s, AV_LOG_ERROR, "Unknown DTS sample rate for HD\n"); |
182 | return AVERROR_INVALIDDATA; |
183 | } |
184 | |
185 | period = ctx->dtshd_rate * (blocks << 5) / sample_rate; |
186 | subtype = spdif_dts4_subtype(period); |
187 | |
188 | if (subtype < 0) { |
189 | av_log(s, AV_LOG_ERROR, "Specified HD rate of %d Hz would require an " |
190 | "impossible repetition period of %d for the current DTS stream" |
191 | " (blocks = %d, sample rate = %d)\n", ctx->dtshd_rate, period, |
192 | blocks << 5, sample_rate); |
193 | return AVERROR(EINVAL); |
194 | } |
195 | |
196 | /* set pkt_offset and DTS IV subtype according to the requested output |
197 | * rate */ |
198 | ctx->pkt_offset = period * 4; |
199 | ctx->data_type = IEC61937_DTSHD | subtype << 8; |
200 | |
201 | /* If the bitrate is too high for transmitting at the selected |
202 | * repetition period setting, strip DTS-HD until a good amount |
203 | * of consecutive non-overflowing HD frames have been observed. |
204 | * This generally only happens if the caller is cramming a Master |
205 | * Audio stream into 192kHz IEC 60958 (which may or may not fit). */ |
206 | if (sizeof(dtshd_start_code) + 2 + pkt_size |
207 | > ctx->pkt_offset - BURST_HEADER_SIZE && core_size) { |
208 | if (!ctx->dtshd_skip) |
209 | av_log(s, AV_LOG_WARNING, "DTS-HD bitrate too high, " |
210 | "temporarily sending core only\n"); |
211 | if (ctx->dtshd_fallback > 0) |
212 | ctx->dtshd_skip = sample_rate * ctx->dtshd_fallback / (blocks << 5); |
213 | else |
214 | /* skip permanently (dtshd_fallback == -1) or just once |
215 | * (dtshd_fallback == 0) */ |
216 | ctx->dtshd_skip = 1; |
217 | } |
218 | if (ctx->dtshd_skip && core_size) { |
219 | pkt_size = core_size; |
220 | if (ctx->dtshd_fallback >= 0) |
221 | --ctx->dtshd_skip; |
222 | } |
223 | |
224 | ctx->out_bytes = sizeof(dtshd_start_code) + 2 + pkt_size; |
225 | |
226 | /* Align so that (length_code & 0xf) == 0x8. This is reportedly needed |
227 | * with some receivers, but the exact requirement is unconfirmed. */ |
228 | ctx->length_code = FFALIGN(ctx->out_bytes + 0x8, 0x10) - 0x8; |
229 | |
230 | av_fast_malloc(&ctx->hd_buf, &ctx->hd_buf_size, ctx->out_bytes); |
231 | if (!ctx->hd_buf) |
232 | return AVERROR(ENOMEM); |
233 | |
234 | ctx->out_buf = ctx->hd_buf; |
235 | |
236 | memcpy(ctx->hd_buf, dtshd_start_code, sizeof(dtshd_start_code)); |
237 | AV_WB16(ctx->hd_buf + sizeof(dtshd_start_code), pkt_size); |
238 | memcpy(ctx->hd_buf + sizeof(dtshd_start_code) + 2, pkt->data, pkt_size); |
239 | |
240 | return 0; |
241 | } |
242 | |
243 | static int spdif_header_dts(AVFormatContext *s, AVPacket *pkt) |
244 | { |
245 | IEC61937Context *ctx = s->priv_data; |
246 | uint32_t syncword_dts = AV_RB32(pkt->data); |
247 | int blocks; |
248 | int sample_rate = 0; |
249 | int core_size = 0; |
250 | |
251 | if (pkt->size < 9) |
252 | return AVERROR_INVALIDDATA; |
253 | |
254 | switch (syncword_dts) { |
255 | case DCA_SYNCWORD_CORE_BE: |
256 | blocks = (AV_RB16(pkt->data + 4) >> 2) & 0x7f; |
257 | core_size = ((AV_RB24(pkt->data + 5) >> 4) & 0x3fff) + 1; |
258 | sample_rate = avpriv_dca_sample_rates[(pkt->data[8] >> 2) & 0x0f]; |
259 | break; |
260 | case DCA_SYNCWORD_CORE_LE: |
261 | blocks = (AV_RL16(pkt->data + 4) >> 2) & 0x7f; |
262 | ctx->extra_bswap = 1; |
263 | break; |
264 | case DCA_SYNCWORD_CORE_14B_BE: |
265 | blocks = |
266 | (((pkt->data[5] & 0x07) << 4) | ((pkt->data[6] & 0x3f) >> 2)); |
267 | break; |
268 | case DCA_SYNCWORD_CORE_14B_LE: |
269 | blocks = |
270 | (((pkt->data[4] & 0x07) << 4) | ((pkt->data[7] & 0x3f) >> 2)); |
271 | ctx->extra_bswap = 1; |
272 | break; |
273 | case DCA_SYNCWORD_SUBSTREAM: |
274 | /* We only handle HD frames that are paired with core. However, |
275 | sometimes DTS-HD streams with core have a stray HD frame without |
276 | core in the beginning of the stream. */ |
277 | av_log(s, AV_LOG_ERROR, "stray DTS-HD frame\n"); |
278 | return AVERROR_INVALIDDATA; |
279 | default: |
280 | av_log(s, AV_LOG_ERROR, "bad DTS syncword 0x%"PRIx32"\n", syncword_dts); |
281 | return AVERROR_INVALIDDATA; |
282 | } |
283 | blocks++; |
284 | |
285 | if (ctx->dtshd_rate) |
286 | /* DTS type IV output requested */ |
287 | return spdif_header_dts4(s, pkt, core_size, sample_rate, blocks); |
288 | |
289 | switch (blocks) { |
290 | case 512 >> 5: ctx->data_type = IEC61937_DTS1; break; |
291 | case 1024 >> 5: ctx->data_type = IEC61937_DTS2; break; |
292 | case 2048 >> 5: ctx->data_type = IEC61937_DTS3; break; |
293 | default: |
294 | av_log(s, AV_LOG_ERROR, "%i samples in DTS frame not supported\n", |
295 | blocks << 5); |
296 | return AVERROR(ENOSYS); |
297 | } |
298 | |
299 | /* discard extraneous data by default */ |
300 | if (core_size && core_size < pkt->size) { |
301 | ctx->out_bytes = core_size; |
302 | ctx->length_code = core_size << 3; |
303 | } |
304 | |
305 | ctx->pkt_offset = blocks << 7; |
306 | |
307 | if (ctx->out_bytes == ctx->pkt_offset) { |
308 | /* The DTS stream fits exactly into the output stream, so skip the |
309 | * preamble as it would not fit in there. This is the case for dts |
310 | * discs and dts-in-wav. */ |
311 | ctx->use_preamble = 0; |
312 | } else if (ctx->out_bytes > ctx->pkt_offset - BURST_HEADER_SIZE) { |
313 | avpriv_request_sample(s, "Unrecognized large DTS frame"); |
314 | /* This will fail with a "bitrate too high" in the caller */ |
315 | } |
316 | |
317 | return 0; |
318 | } |
319 | |
320 | static const enum IEC61937DataType mpeg_data_type[2][3] = { |
321 | // LAYER1 LAYER2 LAYER3 |
322 | { IEC61937_MPEG2_LAYER1_LSF, IEC61937_MPEG2_LAYER2_LSF, IEC61937_MPEG2_LAYER3_LSF }, // MPEG-2 LSF |
323 | { IEC61937_MPEG1_LAYER1, IEC61937_MPEG1_LAYER23, IEC61937_MPEG1_LAYER23 }, // MPEG-1 |
324 | }; |
325 | |
326 | static int spdif_header_mpeg(AVFormatContext *s, AVPacket *pkt) |
327 | { |
328 | IEC61937Context *ctx = s->priv_data; |
329 | int version = (pkt->data[1] >> 3) & 3; |
330 | int layer = 3 - ((pkt->data[1] >> 1) & 3); |
331 | int extension = pkt->data[2] & 1; |
332 | |
333 | if (layer == 3 || version == 1) { |
334 | av_log(s, AV_LOG_ERROR, "Wrong MPEG file format\n"); |
335 | return AVERROR_INVALIDDATA; |
336 | } |
337 | av_log(s, AV_LOG_DEBUG, "version: %i layer: %i extension: %i\n", version, layer, extension); |
338 | if (version == 2 && extension) { |
339 | ctx->data_type = IEC61937_MPEG2_EXT; |
340 | ctx->pkt_offset = 4608; |
341 | } else { |
342 | ctx->data_type = mpeg_data_type [version & 1][layer]; |
343 | ctx->pkt_offset = spdif_mpeg_pkt_offset[version & 1][layer]; |
344 | } |
345 | // TODO Data type dependent info (normal/karaoke, dynamic range control) |
346 | return 0; |
347 | } |
348 | |
349 | static int spdif_header_aac(AVFormatContext *s, AVPacket *pkt) |
350 | { |
351 | IEC61937Context *ctx = s->priv_data; |
352 | AACADTSHeaderInfo hdr; |
353 | GetBitContext gbc; |
354 | int ret; |
355 | |
356 | init_get_bits(&gbc, pkt->data, AAC_ADTS_HEADER_SIZE * 8); |
357 | ret = avpriv_aac_parse_header(&gbc, &hdr); |
358 | if (ret < 0) { |
359 | av_log(s, AV_LOG_ERROR, "Wrong AAC file format\n"); |
360 | return AVERROR_INVALIDDATA; |
361 | } |
362 | |
363 | ctx->pkt_offset = hdr.samples << 2; |
364 | switch (hdr.num_aac_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", hdr.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 | }; |
562 |