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