blob: 3cbf7bd13702e6b1176225524cedce707c78cca0
1 | /* |
2 | * MP3 muxer |
3 | * Copyright (c) 2003 Fabrice Bellard |
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 "avformat.h" |
23 | #include "avio_internal.h" |
24 | #include "id3v1.h" |
25 | #include "id3v2.h" |
26 | #include "rawenc.h" |
27 | #include "libavutil/avstring.h" |
28 | #include "libavcodec/mpegaudio.h" |
29 | #include "libavcodec/mpegaudiodata.h" |
30 | #include "libavcodec/mpegaudiodecheader.h" |
31 | #include "libavutil/intreadwrite.h" |
32 | #include "libavutil/opt.h" |
33 | #include "libavutil/dict.h" |
34 | #include "libavutil/avassert.h" |
35 | #include "libavutil/crc.h" |
36 | #include "libavutil/mathematics.h" |
37 | #include "libavutil/replaygain.h" |
38 | |
39 | static int id3v1_set_string(AVFormatContext *s, const char *key, |
40 | uint8_t *buf, int buf_size) |
41 | { |
42 | AVDictionaryEntry *tag; |
43 | if ((tag = av_dict_get(s->metadata, key, NULL, 0))) |
44 | av_strlcpy(buf, tag->value, buf_size); |
45 | return !!tag; |
46 | } |
47 | |
48 | static int id3v1_create_tag(AVFormatContext *s, uint8_t *buf) |
49 | { |
50 | AVDictionaryEntry *tag; |
51 | int i, count = 0; |
52 | |
53 | memset(buf, 0, ID3v1_TAG_SIZE); /* fail safe */ |
54 | buf[0] = 'T'; |
55 | buf[1] = 'A'; |
56 | buf[2] = 'G'; |
57 | /* we knowingly overspecify each tag length by one byte to compensate for the mandatory null byte added by av_strlcpy */ |
58 | count += id3v1_set_string(s, "TIT2", buf + 3, 30 + 1); //title |
59 | count += id3v1_set_string(s, "TPE1", buf + 33, 30 + 1); //author|artist |
60 | count += id3v1_set_string(s, "TALB", buf + 63, 30 + 1); //album |
61 | count += id3v1_set_string(s, "TDRC", buf + 93, 4 + 1); //date |
62 | count += id3v1_set_string(s, "comment", buf + 97, 30 + 1); |
63 | if ((tag = av_dict_get(s->metadata, "TRCK", NULL, 0))) { //track |
64 | buf[125] = 0; |
65 | buf[126] = atoi(tag->value); |
66 | count++; |
67 | } |
68 | buf[127] = 0xFF; /* default to unknown genre */ |
69 | if ((tag = av_dict_get(s->metadata, "TCON", NULL, 0))) { //genre |
70 | for(i = 0; i <= ID3v1_GENRE_MAX; i++) { |
71 | if (!av_strcasecmp(tag->value, ff_id3v1_genre_str[i])) { |
72 | buf[127] = i; |
73 | count++; |
74 | break; |
75 | } |
76 | } |
77 | } |
78 | return count; |
79 | } |
80 | |
81 | #define XING_NUM_BAGS 400 |
82 | #define XING_TOC_SIZE 100 |
83 | // size of the XING/LAME data, starting from the Xing tag |
84 | #define XING_SIZE 156 |
85 | |
86 | typedef struct MP3Context { |
87 | const AVClass *class; |
88 | ID3v2EncContext id3; |
89 | int id3v2_version; |
90 | int write_id3v1; |
91 | int write_xing; |
92 | |
93 | /* xing header */ |
94 | // a buffer containing the whole XING/LAME frame |
95 | uint8_t *xing_frame; |
96 | int xing_frame_size; |
97 | |
98 | AVCRC audio_crc; // CRC of the audio data |
99 | uint32_t audio_size; // total size of the audio data |
100 | |
101 | // offset of the XING/LAME frame in the file |
102 | int64_t xing_frame_offset; |
103 | // offset of the XING/INFO tag in the frame |
104 | int xing_offset; |
105 | |
106 | int32_t frames; |
107 | int32_t size; |
108 | uint32_t want; |
109 | uint32_t seen; |
110 | uint32_t pos; |
111 | uint64_t bag[XING_NUM_BAGS]; |
112 | int initial_bitrate; |
113 | int has_variable_bitrate; |
114 | int delay; |
115 | int padding; |
116 | |
117 | /* index of the audio stream */ |
118 | int audio_stream_idx; |
119 | /* number of attached pictures we still need to write */ |
120 | int pics_to_write; |
121 | |
122 | /* audio packets are queued here until we get all the attached pictures */ |
123 | AVPacketList *queue, *queue_end; |
124 | } MP3Context; |
125 | |
126 | static const uint8_t xing_offtbl[2][2] = {{32, 17}, {17, 9}}; |
127 | |
128 | /* |
129 | * Write an empty XING header and initialize respective data. |
130 | */ |
131 | static int mp3_write_xing(AVFormatContext *s) |
132 | { |
133 | MP3Context *mp3 = s->priv_data; |
134 | AVCodecParameters *par = s->streams[mp3->audio_stream_idx]->codecpar; |
135 | AVDictionaryEntry *enc = av_dict_get(s->streams[mp3->audio_stream_idx]->metadata, "encoder", NULL, 0); |
136 | AVIOContext *dyn_ctx; |
137 | int32_t header; |
138 | MPADecodeHeader mpah; |
139 | int srate_idx, i, channels; |
140 | int bitrate_idx; |
141 | int best_bitrate_idx = -1; |
142 | int best_bitrate_error = INT_MAX; |
143 | int ret; |
144 | int ver = 0; |
145 | int bytes_needed; |
146 | |
147 | if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) || !mp3->write_xing) |
148 | return 0; |
149 | |
150 | for (i = 0; i < FF_ARRAY_ELEMS(avpriv_mpa_freq_tab); i++) { |
151 | const uint16_t base_freq = avpriv_mpa_freq_tab[i]; |
152 | |
153 | if (par->sample_rate == base_freq) ver = 0x3; // MPEG 1 |
154 | else if (par->sample_rate == base_freq / 2) ver = 0x2; // MPEG 2 |
155 | else if (par->sample_rate == base_freq / 4) ver = 0x0; // MPEG 2.5 |
156 | else continue; |
157 | |
158 | srate_idx = i; |
159 | break; |
160 | } |
161 | if (i == FF_ARRAY_ELEMS(avpriv_mpa_freq_tab)) { |
162 | av_log(s, AV_LOG_WARNING, "Unsupported sample rate, not writing Xing header.\n"); |
163 | return -1; |
164 | } |
165 | |
166 | switch (par->channels) { |
167 | case 1: channels = MPA_MONO; break; |
168 | case 2: channels = MPA_STEREO; break; |
169 | default: av_log(s, AV_LOG_WARNING, "Unsupported number of channels, " |
170 | "not writing Xing header.\n"); |
171 | return -1; |
172 | } |
173 | |
174 | /* dummy MPEG audio header */ |
175 | header = 0xffU << 24; // sync |
176 | header |= (0x7 << 5 | ver << 3 | 0x1 << 1 | 0x1) << 16; // sync/audio-version/layer 3/no crc*/ |
177 | header |= (srate_idx << 2) << 8; |
178 | header |= channels << 6; |
179 | |
180 | for (bitrate_idx = 1; bitrate_idx < 15; bitrate_idx++) { |
181 | int bit_rate = 1000 * avpriv_mpa_bitrate_tab[ver != 3][3 - 1][bitrate_idx]; |
182 | int error = FFABS(bit_rate - par->bit_rate); |
183 | |
184 | if (error < best_bitrate_error) { |
185 | best_bitrate_error = error; |
186 | best_bitrate_idx = bitrate_idx; |
187 | } |
188 | } |
189 | av_assert0(best_bitrate_idx >= 0); |
190 | |
191 | for (bitrate_idx = best_bitrate_idx; ; bitrate_idx++) { |
192 | int32_t mask = bitrate_idx << (4 + 8); |
193 | if (15 == bitrate_idx) |
194 | return -1; |
195 | header |= mask; |
196 | |
197 | ret = avpriv_mpegaudio_decode_header(&mpah, header); |
198 | av_assert0(ret >= 0); |
199 | mp3->xing_offset = xing_offtbl[mpah.lsf == 1][mpah.nb_channels == 1] + 4; |
200 | bytes_needed = mp3->xing_offset + XING_SIZE; |
201 | |
202 | if (bytes_needed <= mpah.frame_size) |
203 | break; |
204 | |
205 | header &= ~mask; |
206 | } |
207 | |
208 | ret = avio_open_dyn_buf(&dyn_ctx); |
209 | if (ret < 0) |
210 | return ret; |
211 | |
212 | avio_wb32(dyn_ctx, header); |
213 | |
214 | ffio_fill(dyn_ctx, 0, mp3->xing_offset - 4); |
215 | ffio_wfourcc(dyn_ctx, "Xing"); |
216 | avio_wb32(dyn_ctx, 0x01 | 0x02 | 0x04 | 0x08); // frames / size / TOC / vbr scale |
217 | |
218 | mp3->size = mpah.frame_size; |
219 | mp3->want=1; |
220 | mp3->seen=0; |
221 | mp3->pos=0; |
222 | |
223 | avio_wb32(dyn_ctx, 0); // frames |
224 | avio_wb32(dyn_ctx, 0); // size |
225 | |
226 | // TOC |
227 | for (i = 0; i < XING_TOC_SIZE; i++) |
228 | avio_w8(dyn_ctx, (uint8_t)(255 * i / XING_TOC_SIZE)); |
229 | |
230 | // vbr quality |
231 | // we write it, because some (broken) tools always expect it to be present |
232 | avio_wb32(dyn_ctx, 0); |
233 | |
234 | // encoder short version string |
235 | if (enc) { |
236 | uint8_t encoder_str[9] = { 0 }; |
237 | if ( strlen(enc->value) > sizeof(encoder_str) |
238 | && !strcmp("Lavc libmp3lame", enc->value)) { |
239 | memcpy(encoder_str, "Lavf lame", 9); |
240 | } else |
241 | memcpy(encoder_str, enc->value, FFMIN(strlen(enc->value), sizeof(encoder_str))); |
242 | |
243 | avio_write(dyn_ctx, encoder_str, sizeof(encoder_str)); |
244 | } else |
245 | avio_write(dyn_ctx, "Lavf\0\0\0\0\0", 9); |
246 | |
247 | avio_w8(dyn_ctx, 0); // tag revision 0 / unknown vbr method |
248 | avio_w8(dyn_ctx, 0); // unknown lowpass filter value |
249 | ffio_fill(dyn_ctx, 0, 8); // empty replaygain fields |
250 | avio_w8(dyn_ctx, 0); // unknown encoding flags |
251 | avio_w8(dyn_ctx, 0); // unknown abr/minimal bitrate |
252 | avio_wb24(dyn_ctx, 0); // empty encoder delay/padding |
253 | |
254 | avio_w8(dyn_ctx, 0); // misc |
255 | avio_w8(dyn_ctx, 0); // mp3gain |
256 | avio_wb16(dyn_ctx, 0); // preset |
257 | |
258 | // audio length and CRCs (will be updated later) |
259 | avio_wb32(dyn_ctx, 0); // music length |
260 | avio_wb16(dyn_ctx, 0); // music crc |
261 | avio_wb16(dyn_ctx, 0); // tag crc |
262 | |
263 | ffio_fill(dyn_ctx, 0, mpah.frame_size - bytes_needed); |
264 | |
265 | mp3->xing_frame_size = avio_close_dyn_buf(dyn_ctx, &mp3->xing_frame); |
266 | mp3->xing_frame_offset = avio_tell(s->pb); |
267 | avio_write(s->pb, mp3->xing_frame, mp3->xing_frame_size); |
268 | |
269 | mp3->audio_size = mp3->xing_frame_size; |
270 | |
271 | return 0; |
272 | } |
273 | |
274 | /* |
275 | * Add a frame to XING data. |
276 | * Following lame's "VbrTag.c". |
277 | */ |
278 | static void mp3_xing_add_frame(MP3Context *mp3, AVPacket *pkt) |
279 | { |
280 | int i; |
281 | |
282 | mp3->frames++; |
283 | mp3->seen++; |
284 | mp3->size += pkt->size; |
285 | |
286 | if (mp3->want == mp3->seen) { |
287 | mp3->bag[mp3->pos] = mp3->size; |
288 | |
289 | if (XING_NUM_BAGS == ++mp3->pos) { |
290 | /* shrink table to half size by throwing away each second bag. */ |
291 | for (i = 1; i < XING_NUM_BAGS; i += 2) |
292 | mp3->bag[i >> 1] = mp3->bag[i]; |
293 | |
294 | /* double wanted amount per bag. */ |
295 | mp3->want *= 2; |
296 | /* adjust current position to half of table size. */ |
297 | mp3->pos = XING_NUM_BAGS / 2; |
298 | } |
299 | |
300 | mp3->seen = 0; |
301 | } |
302 | } |
303 | |
304 | static int mp3_write_audio_packet(AVFormatContext *s, AVPacket *pkt) |
305 | { |
306 | MP3Context *mp3 = s->priv_data; |
307 | |
308 | if (pkt->data && pkt->size >= 4) { |
309 | MPADecodeHeader mpah; |
310 | int ret; |
311 | int av_unused base; |
312 | uint32_t h; |
313 | |
314 | h = AV_RB32(pkt->data); |
315 | ret = avpriv_mpegaudio_decode_header(&mpah, h); |
316 | if (ret >= 0) { |
317 | if (!mp3->initial_bitrate) |
318 | mp3->initial_bitrate = mpah.bit_rate; |
319 | if ((mpah.bit_rate == 0) || (mp3->initial_bitrate != mpah.bit_rate)) |
320 | mp3->has_variable_bitrate = 1; |
321 | } else { |
322 | av_log(s, AV_LOG_WARNING, "Audio packet of size %d (starting with %08"PRIX32"...) " |
323 | "is invalid, writing it anyway.\n", pkt->size, h); |
324 | } |
325 | |
326 | #ifdef FILTER_VBR_HEADERS |
327 | /* filter out XING and INFO headers. */ |
328 | base = 4 + xing_offtbl[mpah.lsf == 1][mpah.nb_channels == 1]; |
329 | |
330 | if (base + 4 <= pkt->size) { |
331 | uint32_t v = AV_RB32(pkt->data + base); |
332 | |
333 | if (MKBETAG('X','i','n','g') == v || MKBETAG('I','n','f','o') == v) |
334 | return 0; |
335 | } |
336 | |
337 | /* filter out VBRI headers. */ |
338 | base = 4 + 32; |
339 | |
340 | if (base + 4 <= pkt->size && MKBETAG('V','B','R','I') == AV_RB32(pkt->data + base)) |
341 | return 0; |
342 | #endif |
343 | |
344 | if (mp3->xing_offset) { |
345 | uint8_t *side_data = NULL; |
346 | int side_data_size = 0; |
347 | |
348 | mp3_xing_add_frame(mp3, pkt); |
349 | mp3->audio_size += pkt->size; |
350 | mp3->audio_crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI_LE), |
351 | mp3->audio_crc, pkt->data, pkt->size); |
352 | |
353 | side_data = av_packet_get_side_data(pkt, |
354 | AV_PKT_DATA_SKIP_SAMPLES, |
355 | &side_data_size); |
356 | if (side_data && side_data_size >= 10) { |
357 | mp3->padding = FFMAX(AV_RL32(side_data + 4) + 528 + 1, 0); |
358 | if (!mp3->delay) |
359 | mp3->delay = FFMAX(AV_RL32(side_data) - 528 - 1, 0); |
360 | } else { |
361 | mp3->padding = 0; |
362 | } |
363 | } |
364 | } |
365 | |
366 | return ff_raw_write_packet(s, pkt); |
367 | } |
368 | |
369 | static int mp3_queue_flush(AVFormatContext *s) |
370 | { |
371 | MP3Context *mp3 = s->priv_data; |
372 | AVPacketList *pktl; |
373 | int ret = 0, write = 1; |
374 | |
375 | ff_id3v2_finish(&mp3->id3, s->pb, s->metadata_header_padding); |
376 | mp3_write_xing(s); |
377 | |
378 | while ((pktl = mp3->queue)) { |
379 | if (write && (ret = mp3_write_audio_packet(s, &pktl->pkt)) < 0) |
380 | write = 0; |
381 | av_packet_unref(&pktl->pkt); |
382 | mp3->queue = pktl->next; |
383 | av_freep(&pktl); |
384 | } |
385 | mp3->queue_end = NULL; |
386 | return ret; |
387 | } |
388 | |
389 | static void mp3_update_xing(AVFormatContext *s) |
390 | { |
391 | MP3Context *mp3 = s->priv_data; |
392 | AVReplayGain *rg; |
393 | uint16_t tag_crc; |
394 | uint8_t *toc; |
395 | int i, rg_size; |
396 | |
397 | /* replace "Xing" identification string with "Info" for CBR files. */ |
398 | if (!mp3->has_variable_bitrate) |
399 | AV_WL32(mp3->xing_frame + mp3->xing_offset, MKTAG('I', 'n', 'f', 'o')); |
400 | |
401 | AV_WB32(mp3->xing_frame + mp3->xing_offset + 8, mp3->frames); |
402 | AV_WB32(mp3->xing_frame + mp3->xing_offset + 12, mp3->size); |
403 | |
404 | toc = mp3->xing_frame + mp3->xing_offset + 16; |
405 | toc[0] = 0; // first toc entry has to be zero. |
406 | for (i = 1; i < XING_TOC_SIZE; ++i) { |
407 | int j = i * mp3->pos / XING_TOC_SIZE; |
408 | int seek_point = 256LL * mp3->bag[j] / mp3->size; |
409 | toc[i] = FFMIN(seek_point, 255); |
410 | } |
411 | |
412 | /* write replaygain */ |
413 | rg = (AVReplayGain*)av_stream_get_side_data(s->streams[0], AV_PKT_DATA_REPLAYGAIN, |
414 | &rg_size); |
415 | if (rg && rg_size >= sizeof(*rg)) { |
416 | uint16_t val; |
417 | |
418 | AV_WB32(mp3->xing_frame + mp3->xing_offset + 131, |
419 | av_rescale(rg->track_peak, 1 << 23, 100000)); |
420 | |
421 | if (rg->track_gain != INT32_MIN) { |
422 | val = FFABS(rg->track_gain / 10000) & ((1 << 9) - 1); |
423 | val |= (rg->track_gain < 0) << 9; |
424 | val |= 1 << 13; |
425 | AV_WB16(mp3->xing_frame + mp3->xing_offset + 135, val); |
426 | } |
427 | |
428 | if (rg->album_gain != INT32_MIN) { |
429 | val = FFABS(rg->album_gain / 10000) & ((1 << 9) - 1); |
430 | val |= (rg->album_gain < 0) << 9; |
431 | val |= 1 << 14; |
432 | AV_WB16(mp3->xing_frame + mp3->xing_offset + 137, val); |
433 | } |
434 | } |
435 | |
436 | /* write encoder delay/padding */ |
437 | if (mp3->delay >= 1 << 12) { |
438 | mp3->delay = (1 << 12) - 1; |
439 | av_log(s, AV_LOG_WARNING, "Too many samples of initial padding.\n"); |
440 | } |
441 | if (mp3->padding >= 1 << 12) { |
442 | mp3->padding = (1 << 12) - 1; |
443 | av_log(s, AV_LOG_WARNING, "Too many samples of trailing padding.\n"); |
444 | } |
445 | AV_WB24(mp3->xing_frame + mp3->xing_offset + 141, (mp3->delay << 12) + mp3->padding); |
446 | |
447 | AV_WB32(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 8, mp3->audio_size); |
448 | AV_WB16(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 4, mp3->audio_crc); |
449 | |
450 | tag_crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI_LE), 0, mp3->xing_frame, 190); |
451 | AV_WB16(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 2, tag_crc); |
452 | |
453 | avio_seek(s->pb, mp3->xing_frame_offset, SEEK_SET); |
454 | avio_write(s->pb, mp3->xing_frame, mp3->xing_frame_size); |
455 | avio_seek(s->pb, 0, SEEK_END); |
456 | } |
457 | |
458 | static int mp3_write_trailer(struct AVFormatContext *s) |
459 | { |
460 | uint8_t buf[ID3v1_TAG_SIZE]; |
461 | MP3Context *mp3 = s->priv_data; |
462 | |
463 | if (mp3->pics_to_write) { |
464 | av_log(s, AV_LOG_WARNING, "No packets were sent for some of the " |
465 | "attached pictures.\n"); |
466 | mp3_queue_flush(s); |
467 | } |
468 | |
469 | /* write the id3v1 tag */ |
470 | if (mp3->write_id3v1 && id3v1_create_tag(s, buf) > 0) { |
471 | avio_write(s->pb, buf, ID3v1_TAG_SIZE); |
472 | } |
473 | |
474 | if (mp3->xing_offset) |
475 | mp3_update_xing(s); |
476 | |
477 | av_freep(&mp3->xing_frame); |
478 | |
479 | return 0; |
480 | } |
481 | |
482 | static int query_codec(enum AVCodecID id, int std_compliance) |
483 | { |
484 | const CodecMime *cm= ff_id3v2_mime_tags; |
485 | while(cm->id != AV_CODEC_ID_NONE) { |
486 | if(id == cm->id) |
487 | return MKTAG('A', 'P', 'I', 'C'); |
488 | cm++; |
489 | } |
490 | return -1; |
491 | } |
492 | |
493 | static const AVOption options[] = { |
494 | { "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.", |
495 | offsetof(MP3Context, id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 0, 4, AV_OPT_FLAG_ENCODING_PARAM}, |
496 | { "write_id3v1", "Enable ID3v1 writing. ID3v1 tags are written in UTF-8 which may not be supported by most software.", |
497 | offsetof(MP3Context, write_id3v1), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM}, |
498 | { "write_xing", "Write the Xing header containing file duration.", |
499 | offsetof(MP3Context, write_xing), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM}, |
500 | { NULL }, |
501 | }; |
502 | |
503 | static const AVClass mp3_muxer_class = { |
504 | .class_name = "MP3 muxer", |
505 | .item_name = av_default_item_name, |
506 | .option = options, |
507 | .version = LIBAVUTIL_VERSION_INT, |
508 | }; |
509 | |
510 | static int mp3_write_packet(AVFormatContext *s, AVPacket *pkt) |
511 | { |
512 | MP3Context *mp3 = s->priv_data; |
513 | |
514 | if (pkt->stream_index == mp3->audio_stream_idx) { |
515 | if (mp3->pics_to_write) { |
516 | /* buffer audio packets until we get all the pictures */ |
517 | AVPacketList *pktl = av_mallocz(sizeof(*pktl)); |
518 | int ret; |
519 | if (!pktl) { |
520 | av_log(s, AV_LOG_WARNING, "Not enough memory to buffer audio. Skipping picture streams\n"); |
521 | mp3->pics_to_write = 0; |
522 | mp3_queue_flush(s); |
523 | return mp3_write_audio_packet(s, pkt); |
524 | } |
525 | |
526 | ret = av_copy_packet(&pktl->pkt, pkt); |
527 | if (ret < 0) { |
528 | av_freep(&pktl); |
529 | return ret; |
530 | } |
531 | |
532 | if (mp3->queue_end) |
533 | mp3->queue_end->next = pktl; |
534 | else |
535 | mp3->queue = pktl; |
536 | mp3->queue_end = pktl; |
537 | } else |
538 | return mp3_write_audio_packet(s, pkt); |
539 | } else { |
540 | int ret; |
541 | |
542 | /* warn only once for each stream */ |
543 | if (s->streams[pkt->stream_index]->nb_frames == 1) { |
544 | av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d," |
545 | " ignoring.\n", pkt->stream_index); |
546 | } |
547 | if (!mp3->pics_to_write || s->streams[pkt->stream_index]->nb_frames >= 1) |
548 | return 0; |
549 | |
550 | if ((ret = ff_id3v2_write_apic(s, &mp3->id3, pkt)) < 0) |
551 | return ret; |
552 | mp3->pics_to_write--; |
553 | |
554 | /* flush the buffered audio packets */ |
555 | if (!mp3->pics_to_write && |
556 | (ret = mp3_queue_flush(s)) < 0) |
557 | return ret; |
558 | } |
559 | |
560 | return 0; |
561 | } |
562 | |
563 | /** |
564 | * Write an ID3v2 header at beginning of stream |
565 | */ |
566 | |
567 | static int mp3_write_header(struct AVFormatContext *s) |
568 | { |
569 | MP3Context *mp3 = s->priv_data; |
570 | int ret, i; |
571 | |
572 | if (mp3->id3v2_version && |
573 | mp3->id3v2_version != 3 && |
574 | mp3->id3v2_version != 4) { |
575 | av_log(s, AV_LOG_ERROR, "Invalid ID3v2 version requested: %d. Only " |
576 | "3, 4 or 0 (disabled) are allowed.\n", mp3->id3v2_version); |
577 | return AVERROR(EINVAL); |
578 | } |
579 | |
580 | /* check the streams -- we want exactly one audio and arbitrary number of |
581 | * video (attached pictures) */ |
582 | mp3->audio_stream_idx = -1; |
583 | for (i = 0; i < s->nb_streams; i++) { |
584 | AVStream *st = s->streams[i]; |
585 | if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { |
586 | if (mp3->audio_stream_idx >= 0 || st->codecpar->codec_id != AV_CODEC_ID_MP3) { |
587 | av_log(s, AV_LOG_ERROR, "Invalid audio stream. Exactly one MP3 " |
588 | "audio stream is required.\n"); |
589 | return AVERROR(EINVAL); |
590 | } |
591 | mp3->audio_stream_idx = i; |
592 | } else if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) { |
593 | av_log(s, AV_LOG_ERROR, "Only audio streams and pictures are allowed in MP3.\n"); |
594 | return AVERROR(EINVAL); |
595 | } |
596 | } |
597 | if (mp3->audio_stream_idx < 0) { |
598 | av_log(s, AV_LOG_ERROR, "No audio stream present.\n"); |
599 | return AVERROR(EINVAL); |
600 | } |
601 | mp3->pics_to_write = s->nb_streams - 1; |
602 | |
603 | if (mp3->pics_to_write && !mp3->id3v2_version) { |
604 | av_log(s, AV_LOG_ERROR, "Attached pictures were requested, but the " |
605 | "ID3v2 header is disabled.\n"); |
606 | return AVERROR(EINVAL); |
607 | } |
608 | |
609 | if (mp3->id3v2_version) { |
610 | ff_id3v2_start(&mp3->id3, s->pb, mp3->id3v2_version, ID3v2_DEFAULT_MAGIC); |
611 | ret = ff_id3v2_write_metadata(s, &mp3->id3); |
612 | if (ret < 0) |
613 | return ret; |
614 | } |
615 | |
616 | if (!mp3->pics_to_write) { |
617 | if (mp3->id3v2_version) |
618 | ff_id3v2_finish(&mp3->id3, s->pb, s->metadata_header_padding); |
619 | mp3_write_xing(s); |
620 | } |
621 | |
622 | return 0; |
623 | } |
624 | |
625 | AVOutputFormat ff_mp3_muxer = { |
626 | .name = "mp3", |
627 | .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"), |
628 | .mime_type = "audio/mpeg", |
629 | .extensions = "mp3", |
630 | .priv_data_size = sizeof(MP3Context), |
631 | .audio_codec = AV_CODEC_ID_MP3, |
632 | .video_codec = AV_CODEC_ID_PNG, |
633 | .write_header = mp3_write_header, |
634 | .write_packet = mp3_write_packet, |
635 | .write_trailer = mp3_write_trailer, |
636 | .query_codec = query_codec, |
637 | .flags = AVFMT_NOTIMESTAMPS, |
638 | .priv_class = &mp3_muxer_class, |
639 | }; |
640 |