Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * raw FLAC muxer | |
3 | * Copyright (c) 2006-2009 Justin Ruggles | |
4 | * | |
5 | * This file is part of FFmpeg. | |
6 | * | |
7 | * FFmpeg is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU Lesser General Public | |
9 | * License as published by the Free Software Foundation; either | |
10 | * version 2.1 of the License, or (at your option) any later version. | |
11 | * | |
12 | * FFmpeg is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * Lesser General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU Lesser General Public | |
18 | * License along with FFmpeg; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 | */ | |
21 | ||
22 | #include "libavutil/channel_layout.h" | |
23 | #include "libavutil/opt.h" | |
24 | #include "libavcodec/flac.h" | |
25 | #include "avformat.h" | |
26 | #include "avio_internal.h" | |
27 | #include "flacenc.h" | |
28 | #include "vorbiscomment.h" | |
29 | #include "libavcodec/bytestream.h" | |
30 | ||
31 | ||
32 | typedef struct FlacMuxerContext { | |
33 | const AVClass *class; | |
34 | int write_header; | |
35 | ||
36 | /* updated streaminfo sent by the encoder at the end */ | |
37 | uint8_t *streaminfo; | |
38 | } FlacMuxerContext; | |
39 | ||
40 | static int flac_write_block_padding(AVIOContext *pb, unsigned int n_padding_bytes, | |
41 | int last_block) | |
42 | { | |
43 | avio_w8(pb, last_block ? 0x81 : 0x01); | |
44 | avio_wb24(pb, n_padding_bytes); | |
45 | ffio_fill(pb, 0, n_padding_bytes); | |
46 | return 0; | |
47 | } | |
48 | ||
49 | static int flac_write_block_comment(AVIOContext *pb, AVDictionary **m, | |
50 | int last_block, int bitexact) | |
51 | { | |
52 | const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT; | |
53 | unsigned int len; | |
54 | uint8_t *p, *p0; | |
55 | ||
56 | ff_metadata_conv(m, ff_vorbiscomment_metadata_conv, NULL); | |
57 | ||
58 | len = ff_vorbiscomment_length(*m, vendor); | |
59 | p0 = av_malloc(len+4); | |
60 | if (!p0) | |
61 | return AVERROR(ENOMEM); | |
62 | p = p0; | |
63 | ||
64 | bytestream_put_byte(&p, last_block ? 0x84 : 0x04); | |
65 | bytestream_put_be24(&p, len); | |
66 | ff_vorbiscomment_write(&p, m, vendor); | |
67 | ||
68 | avio_write(pb, p0, len+4); | |
69 | av_freep(&p0); | |
70 | p = NULL; | |
71 | ||
72 | return 0; | |
73 | } | |
74 | ||
75 | static int flac_write_header(struct AVFormatContext *s) | |
76 | { | |
77 | int ret; | |
78 | int padding = s->metadata_header_padding; | |
79 | AVCodecContext *codec = s->streams[0]->codec; | |
80 | FlacMuxerContext *c = s->priv_data; | |
81 | ||
82 | if (!c->write_header) | |
83 | return 0; | |
84 | ||
85 | if (s->nb_streams > 1) { | |
86 | av_log(s, AV_LOG_ERROR, "only one stream is supported\n"); | |
87 | return AVERROR(EINVAL); | |
88 | } | |
89 | if (codec->codec_id != AV_CODEC_ID_FLAC) { | |
90 | av_log(s, AV_LOG_ERROR, "unsupported codec\n"); | |
91 | return AVERROR(EINVAL); | |
92 | } | |
93 | ||
94 | if (padding < 0) | |
95 | padding = 8192; | |
96 | /* The FLAC specification states that 24 bits are used to represent the | |
97 | * size of a metadata block so we must clip this value to 2^24-1. */ | |
98 | padding = av_clip_c(padding, 0, 16777215); | |
99 | ||
100 | ret = ff_flac_write_header(s->pb, codec->extradata, | |
101 | codec->extradata_size, 0); | |
102 | if (ret) | |
103 | return ret; | |
104 | ||
105 | /* add the channel layout tag */ | |
106 | if (codec->channel_layout && | |
107 | !(codec->channel_layout & ~0x3ffffULL) && | |
108 | !ff_flac_is_native_layout(codec->channel_layout)) { | |
109 | AVDictionaryEntry *chmask = av_dict_get(s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", | |
110 | NULL, 0); | |
111 | ||
112 | if (chmask) { | |
113 | av_log(s, AV_LOG_WARNING, "A WAVEFORMATEXTENSIBLE_CHANNEL_MASK is " | |
114 | "already present, this muxer will not overwrite it.\n"); | |
115 | } else { | |
116 | uint8_t buf[32]; | |
117 | snprintf(buf, sizeof(buf), "0x%"PRIx64, codec->channel_layout); | |
118 | av_dict_set(&s->metadata, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0); | |
119 | } | |
120 | } | |
121 | ||
122 | ret = flac_write_block_comment(s->pb, &s->metadata, !padding, | |
123 | s->flags & AVFMT_FLAG_BITEXACT); | |
124 | if (ret) | |
125 | return ret; | |
126 | ||
127 | /* The command line flac encoder defaults to placing a seekpoint | |
128 | * every 10s. So one might add padding to allow that later | |
129 | * but there seems to be no simple way to get the duration here. | |
130 | * So just add the amount requested by the user. */ | |
131 | if (padding) | |
132 | flac_write_block_padding(s->pb, padding, 1); | |
133 | ||
134 | return ret; | |
135 | } | |
136 | ||
137 | static int flac_write_trailer(struct AVFormatContext *s) | |
138 | { | |
139 | AVIOContext *pb = s->pb; | |
140 | int64_t file_size; | |
141 | FlacMuxerContext *c = s->priv_data; | |
142 | uint8_t *streaminfo = c->streaminfo ? c->streaminfo : | |
143 | s->streams[0]->codec->extradata; | |
144 | ||
145 | if (!c->write_header || !streaminfo) | |
146 | return 0; | |
147 | ||
148 | if (pb->seekable) { | |
149 | /* rewrite the STREAMINFO header block data */ | |
150 | file_size = avio_tell(pb); | |
151 | avio_seek(pb, 8, SEEK_SET); | |
152 | avio_write(pb, streaminfo, FLAC_STREAMINFO_SIZE); | |
153 | avio_seek(pb, file_size, SEEK_SET); | |
154 | avio_flush(pb); | |
155 | } else { | |
156 | av_log(s, AV_LOG_WARNING, "unable to rewrite FLAC header.\n"); | |
157 | } | |
158 | ||
159 | av_freep(&c->streaminfo); | |
160 | ||
161 | return 0; | |
162 | } | |
163 | ||
164 | static int flac_write_packet(struct AVFormatContext *s, AVPacket *pkt) | |
165 | { | |
166 | FlacMuxerContext *c = s->priv_data; | |
167 | uint8_t *streaminfo; | |
168 | int streaminfo_size; | |
169 | ||
170 | /* check for updated streaminfo */ | |
171 | streaminfo = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, | |
172 | &streaminfo_size); | |
173 | if (streaminfo && streaminfo_size == FLAC_STREAMINFO_SIZE) { | |
174 | av_freep(&c->streaminfo); | |
175 | ||
176 | c->streaminfo = av_malloc(FLAC_STREAMINFO_SIZE); | |
177 | if (!c->streaminfo) | |
178 | return AVERROR(ENOMEM); | |
179 | memcpy(c->streaminfo, streaminfo, FLAC_STREAMINFO_SIZE); | |
180 | } | |
181 | ||
182 | if (pkt->size) | |
183 | avio_write(s->pb, pkt->data, pkt->size); | |
184 | return 0; | |
185 | } | |
186 | ||
187 | static const AVOption flacenc_options[] = { | |
188 | { "write_header", "Write the file header", offsetof(FlacMuxerContext, write_header), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM }, | |
189 | { NULL }, | |
190 | }; | |
191 | ||
192 | static const AVClass flac_muxer_class = { | |
193 | .class_name = "flac muxer", | |
194 | .item_name = av_default_item_name, | |
195 | .option = flacenc_options, | |
196 | .version = LIBAVUTIL_VERSION_INT, | |
197 | }; | |
198 | ||
199 | AVOutputFormat ff_flac_muxer = { | |
200 | .name = "flac", | |
201 | .long_name = NULL_IF_CONFIG_SMALL("raw FLAC"), | |
202 | .priv_data_size = sizeof(FlacMuxerContext), | |
203 | .mime_type = "audio/x-flac", | |
204 | .extensions = "flac", | |
205 | .audio_codec = AV_CODEC_ID_FLAC, | |
206 | .video_codec = AV_CODEC_ID_NONE, | |
207 | .write_header = flac_write_header, | |
208 | .write_packet = flac_write_packet, | |
209 | .write_trailer = flac_write_trailer, | |
210 | .flags = AVFMT_NOTIMESTAMPS, | |
211 | .priv_class = &flac_muxer_class, | |
212 | }; |