FFmpeg
mp3enc.c
Go to the documentation of this file.
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"
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 {
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 // refer to: http://id3.org/ID3v1
50 {
52  int i, count = 0;
53 
54  memset(buf, 0, ID3v1_TAG_SIZE); /* fail safe */
55  buf[0] = 'T';
56  buf[1] = 'A';
57  buf[2] = 'G';
58  /* we knowingly overspecify each tag length by one byte to compensate for the mandatory null byte added by av_strlcpy */
59  count += id3v1_set_string(s, "TIT2", buf + 3, 30 + 1); //title
60  count += id3v1_set_string(s, "TPE1", buf + 33, 30 + 1); //author|artist
61  count += id3v1_set_string(s, "TALB", buf + 63, 30 + 1); //album
62  if ((tag = av_dict_get(s->metadata, "TYER", NULL, 0))) { //year
63  av_strlcpy(buf + 93, tag->value, 4 + 1);
64  count++;
65  } else if ((tag = av_dict_get(s->metadata, "TDRC", NULL, 0))) {
66  av_strlcpy(buf + 93, tag->value, 4 + 1);
67  count++;
68  } else if ((tag = av_dict_get(s->metadata, "TDAT", NULL, 0))) {
69  av_strlcpy(buf + 93, tag->value, 4 + 1);
70  count++;
71  }
72 
73  count += id3v1_set_string(s, "comment", buf + 97, 30 + 1);
74  if ((tag = av_dict_get(s->metadata, "TRCK", NULL, 0))) { //track
75  buf[125] = 0;
76  buf[126] = atoi(tag->value);
77  count++;
78  }
79  buf[127] = 0xFF; /* default to unknown genre */
80  if ((tag = av_dict_get(s->metadata, "TCON", NULL, 0))) { //genre
81  for(i = 0; i <= ID3v1_GENRE_MAX; i++) {
82  if (!av_strcasecmp(tag->value, ff_id3v1_genre_str[i])) {
83  buf[127] = i;
84  count++;
85  break;
86  }
87  }
88  }
89  return count;
90 }
91 
92 #define XING_NUM_BAGS 400
93 #define XING_TOC_SIZE 100
94 // size of the XING/LAME data, starting from the Xing tag
95 #define XING_SIZE 156
96 
97 typedef struct MP3Context {
98  const AVClass *class;
103 
104  /* xing header */
105  // a buffer containing the whole XING/LAME frame
108 
109  AVCRC audio_crc; // CRC of the audio data
110  uint32_t audio_size; // total size of the audio data
111 
112  // offset of the XING/LAME frame in the file
114  // offset of the XING/INFO tag in the frame
116 
119  uint32_t want;
120  uint32_t seen;
121  uint32_t pos;
122  uint64_t bag[XING_NUM_BAGS];
125  int delay;
126  int padding;
127 
128  /* index of the audio stream */
130  /* number of attached pictures we still need to write */
132 
133  /* audio packets are queued here until we get all the attached pictures */
135 } MP3Context;
136 
137 static const uint8_t xing_offtbl[2][2] = {{32, 17}, {17, 9}};
138 
139 /*
140  * Write an empty XING header and initialize respective data.
141  */
143 {
144  MP3Context *mp3 = s->priv_data;
146  AVDictionaryEntry *enc = av_dict_get(s->streams[mp3->audio_stream_idx]->metadata, "encoder", NULL, 0);
147  AVIOContext *dyn_ctx;
148  int32_t header;
149  MPADecodeHeader mpah;
150  int srate_idx, i, channels;
151  int bitrate_idx;
152  int best_bitrate_idx = -1;
153  int best_bitrate_error = INT_MAX;
154  int ret;
155  int ver = 0;
156  int bytes_needed;
157 
158  if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) || !mp3->write_xing)
159  return 0;
160 
161  for (i = 0; i < FF_ARRAY_ELEMS(avpriv_mpa_freq_tab); i++) {
162  const uint16_t base_freq = avpriv_mpa_freq_tab[i];
163 
164  if (par->sample_rate == base_freq) ver = 0x3; // MPEG 1
165  else if (par->sample_rate == base_freq / 2) ver = 0x2; // MPEG 2
166  else if (par->sample_rate == base_freq / 4) ver = 0x0; // MPEG 2.5
167  else continue;
168 
169  srate_idx = i;
170  break;
171  }
173  av_log(s, AV_LOG_WARNING, "Unsupported sample rate, not writing Xing header.\n");
174  return -1;
175  }
176 
177  switch (par->channels) {
178  case 1: channels = MPA_MONO; break;
179  case 2: channels = MPA_STEREO; break;
180  default: av_log(s, AV_LOG_WARNING, "Unsupported number of channels, "
181  "not writing Xing header.\n");
182  return -1;
183  }
184 
185  /* dummy MPEG audio header */
186  header = 0xffU << 24; // sync
187  header |= (0x7 << 5 | ver << 3 | 0x1 << 1 | 0x1) << 16; // sync/audio-version/layer 3/no crc*/
188  header |= (srate_idx << 2) << 8;
189  header |= channels << 6;
190 
191  for (bitrate_idx = 1; bitrate_idx < 15; bitrate_idx++) {
192  int bit_rate = 1000 * avpriv_mpa_bitrate_tab[ver != 3][3 - 1][bitrate_idx];
193  int error = FFABS(bit_rate - par->bit_rate);
194 
195  if (error < best_bitrate_error) {
196  best_bitrate_error = error;
197  best_bitrate_idx = bitrate_idx;
198  }
199  }
200  av_assert0(best_bitrate_idx >= 0);
201 
202  for (bitrate_idx = best_bitrate_idx; ; bitrate_idx++) {
203  int32_t mask = bitrate_idx << (4 + 8);
204  if (15 == bitrate_idx)
205  return -1;
206  header |= mask;
207 
208  ret = avpriv_mpegaudio_decode_header(&mpah, header);
209  av_assert0(ret >= 0);
210  mp3->xing_offset = xing_offtbl[mpah.lsf == 1][mpah.nb_channels == 1] + 4;
211  bytes_needed = mp3->xing_offset + XING_SIZE;
212 
213  if (bytes_needed <= mpah.frame_size)
214  break;
215 
216  header &= ~mask;
217  }
218 
219  ret = avio_open_dyn_buf(&dyn_ctx);
220  if (ret < 0)
221  return ret;
222 
223  avio_wb32(dyn_ctx, header);
224 
225  ffio_fill(dyn_ctx, 0, mp3->xing_offset - 4);
226  ffio_wfourcc(dyn_ctx, "Xing");
227  avio_wb32(dyn_ctx, 0x01 | 0x02 | 0x04 | 0x08); // frames / size / TOC / vbr scale
228 
229  mp3->size = mpah.frame_size;
230  mp3->want=1;
231  mp3->seen=0;
232  mp3->pos=0;
233 
234  avio_wb32(dyn_ctx, 0); // frames
235  avio_wb32(dyn_ctx, 0); // size
236 
237  // TOC
238  for (i = 0; i < XING_TOC_SIZE; i++)
239  avio_w8(dyn_ctx, (uint8_t)(255 * i / XING_TOC_SIZE));
240 
241  // vbr quality
242  // we write it, because some (broken) tools always expect it to be present
243  avio_wb32(dyn_ctx, 0);
244 
245  // encoder short version string
246  if (enc) {
247  uint8_t encoder_str[9] = { 0 };
248  if ( strlen(enc->value) > sizeof(encoder_str)
249  && !strcmp("Lavc libmp3lame", enc->value)) {
250  memcpy(encoder_str, "Lavf lame", 9);
251  } else
252  memcpy(encoder_str, enc->value, FFMIN(strlen(enc->value), sizeof(encoder_str)));
253 
254  avio_write(dyn_ctx, encoder_str, sizeof(encoder_str));
255  } else
256  avio_write(dyn_ctx, "Lavf\0\0\0\0\0", 9);
257 
258  avio_w8(dyn_ctx, 0); // tag revision 0 / unknown vbr method
259  avio_w8(dyn_ctx, 0); // unknown lowpass filter value
260  ffio_fill(dyn_ctx, 0, 8); // empty replaygain fields
261  avio_w8(dyn_ctx, 0); // unknown encoding flags
262  avio_w8(dyn_ctx, 0); // unknown abr/minimal bitrate
263  avio_wb24(dyn_ctx, 0); // empty encoder delay/padding
264 
265  avio_w8(dyn_ctx, 0); // misc
266  avio_w8(dyn_ctx, 0); // mp3gain
267  avio_wb16(dyn_ctx, 0); // preset
268 
269  // audio length and CRCs (will be updated later)
270  avio_wb32(dyn_ctx, 0); // music length
271  avio_wb16(dyn_ctx, 0); // music crc
272  avio_wb16(dyn_ctx, 0); // tag crc
273 
274  ffio_fill(dyn_ctx, 0, mpah.frame_size - bytes_needed);
275 
276  mp3->xing_frame_size = avio_close_dyn_buf(dyn_ctx, &mp3->xing_frame);
277  mp3->xing_frame_offset = avio_tell(s->pb);
278  avio_write(s->pb, mp3->xing_frame, mp3->xing_frame_size);
279 
280  mp3->audio_size = mp3->xing_frame_size;
281 
282  return 0;
283 }
284 
285 /*
286  * Add a frame to XING data.
287  * Following lame's "VbrTag.c".
288  */
290 {
291  int i;
292 
293  mp3->frames++;
294  mp3->seen++;
295  mp3->size += pkt->size;
296 
297  if (mp3->want == mp3->seen) {
298  mp3->bag[mp3->pos] = mp3->size;
299 
300  if (XING_NUM_BAGS == ++mp3->pos) {
301  /* shrink table to half size by throwing away each second bag. */
302  for (i = 1; i < XING_NUM_BAGS; i += 2)
303  mp3->bag[i >> 1] = mp3->bag[i];
304 
305  /* double wanted amount per bag. */
306  mp3->want *= 2;
307  /* adjust current position to half of table size. */
308  mp3->pos = XING_NUM_BAGS / 2;
309  }
310 
311  mp3->seen = 0;
312  }
313 }
314 
316 {
317  MP3Context *mp3 = s->priv_data;
318 
319  if (pkt->data && pkt->size >= 4) {
320  MPADecodeHeader mpah;
321  int ret;
322  int av_unused base;
323  uint32_t h;
324 
325  h = AV_RB32(pkt->data);
326  ret = avpriv_mpegaudio_decode_header(&mpah, h);
327  if (ret >= 0) {
328  if (!mp3->initial_bitrate)
329  mp3->initial_bitrate = mpah.bit_rate;
330  if ((mpah.bit_rate == 0) || (mp3->initial_bitrate != mpah.bit_rate))
331  mp3->has_variable_bitrate = 1;
332  } else {
333  av_log(s, AV_LOG_WARNING, "Audio packet of size %d (starting with %08"PRIX32"...) "
334  "is invalid, writing it anyway.\n", pkt->size, h);
335  }
336 
337 #ifdef FILTER_VBR_HEADERS
338  /* filter out XING and INFO headers. */
339  base = 4 + xing_offtbl[mpah.lsf == 1][mpah.nb_channels == 1];
340 
341  if (base + 4 <= pkt->size) {
342  uint32_t v = AV_RB32(pkt->data + base);
343 
344  if (MKBETAG('X','i','n','g') == v || MKBETAG('I','n','f','o') == v)
345  return 0;
346  }
347 
348  /* filter out VBRI headers. */
349  base = 4 + 32;
350 
351  if (base + 4 <= pkt->size && MKBETAG('V','B','R','I') == AV_RB32(pkt->data + base))
352  return 0;
353 #endif
354 
355  if (mp3->xing_offset) {
356  uint8_t *side_data = NULL;
357  int side_data_size = 0;
358 
359  mp3_xing_add_frame(mp3, pkt);
360  mp3->audio_size += pkt->size;
362  mp3->audio_crc, pkt->data, pkt->size);
363 
364  side_data = av_packet_get_side_data(pkt,
366  &side_data_size);
367  if (side_data && side_data_size >= 10) {
368  mp3->padding = FFMAX(AV_RL32(side_data + 4) + 528 + 1, 0);
369  if (!mp3->delay)
370  mp3->delay = FFMAX(AV_RL32(side_data) - 528 - 1, 0);
371  } else {
372  mp3->padding = 0;
373  }
374  }
375  }
376 
377  return ff_raw_write_packet(s, pkt);
378 }
379 
381 {
382  MP3Context *mp3 = s->priv_data;
383  AVPacket pkt;
384  int ret = 0, write = 1;
385 
387  mp3_write_xing(s);
388 
389  while (mp3->queue) {
390  ff_packet_list_get(&mp3->queue, &mp3->queue_end, &pkt);
391  if (write && (ret = mp3_write_audio_packet(s, &pkt)) < 0)
392  write = 0;
393  av_packet_unref(&pkt);
394  }
395  return ret;
396 }
397 
399 {
400  MP3Context *mp3 = s->priv_data;
401  AVReplayGain *rg;
402  uint16_t tag_crc;
403  uint8_t *toc;
404  int i, rg_size;
405  int64_t old_pos = avio_tell(s->pb);
406 
407  /* replace "Xing" identification string with "Info" for CBR files. */
408  if (!mp3->has_variable_bitrate)
409  AV_WL32(mp3->xing_frame + mp3->xing_offset, MKTAG('I', 'n', 'f', 'o'));
410 
411  AV_WB32(mp3->xing_frame + mp3->xing_offset + 8, mp3->frames);
412  AV_WB32(mp3->xing_frame + mp3->xing_offset + 12, mp3->size);
413 
414  toc = mp3->xing_frame + mp3->xing_offset + 16;
415  toc[0] = 0; // first toc entry has to be zero.
416  for (i = 1; i < XING_TOC_SIZE; ++i) {
417  int j = i * mp3->pos / XING_TOC_SIZE;
418  int seek_point = 256LL * mp3->bag[j] / mp3->size;
419  toc[i] = FFMIN(seek_point, 255);
420  }
421 
422  /* write replaygain */
424  &rg_size);
425  if (rg && rg_size >= sizeof(*rg)) {
426  uint16_t val;
427 
428  AV_WB32(mp3->xing_frame + mp3->xing_offset + 131,
429  av_rescale(rg->track_peak, 1 << 23, 100000));
430 
431  if (rg->track_gain != INT32_MIN) {
432  val = FFABS(rg->track_gain / 10000) & ((1 << 9) - 1);
433  val |= (rg->track_gain < 0) << 9;
434  val |= 1 << 13;
435  AV_WB16(mp3->xing_frame + mp3->xing_offset + 135, val);
436  }
437 
438  if (rg->album_gain != INT32_MIN) {
439  val = FFABS(rg->album_gain / 10000) & ((1 << 9) - 1);
440  val |= (rg->album_gain < 0) << 9;
441  val |= 1 << 14;
442  AV_WB16(mp3->xing_frame + mp3->xing_offset + 137, val);
443  }
444  }
445 
446  /* write encoder delay/padding */
447  if (mp3->delay >= 1 << 12) {
448  mp3->delay = (1 << 12) - 1;
449  av_log(s, AV_LOG_WARNING, "Too many samples of initial padding.\n");
450  }
451  if (mp3->padding >= 1 << 12) {
452  mp3->padding = (1 << 12) - 1;
453  av_log(s, AV_LOG_WARNING, "Too many samples of trailing padding.\n");
454  }
455  AV_WB24(mp3->xing_frame + mp3->xing_offset + 141, (mp3->delay << 12) + mp3->padding);
456 
457  AV_WB32(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 8, mp3->audio_size);
458  AV_WB16(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 4, mp3->audio_crc);
459 
460  tag_crc = av_crc(av_crc_get_table(AV_CRC_16_ANSI_LE), 0, mp3->xing_frame, 190);
461  AV_WB16(mp3->xing_frame + mp3->xing_offset + XING_SIZE - 2, tag_crc);
462 
463  avio_seek(s->pb, mp3->xing_frame_offset, SEEK_SET);
464  avio_write(s->pb, mp3->xing_frame, mp3->xing_frame_size);
465  avio_seek(s->pb, old_pos, SEEK_SET);
466 }
467 
469 {
470  uint8_t buf[ID3v1_TAG_SIZE];
471  MP3Context *mp3 = s->priv_data;
472 
473  if (mp3->pics_to_write) {
474  av_log(s, AV_LOG_WARNING, "No packets were sent for some of the "
475  "attached pictures.\n");
476  mp3_queue_flush(s);
477  }
478 
479  /* write the id3v1 tag */
480  if (mp3->write_id3v1 && id3v1_create_tag(s, buf) > 0) {
481  avio_write(s->pb, buf, ID3v1_TAG_SIZE);
482  }
483 
484  if (mp3->xing_offset)
485  mp3_update_xing(s);
486 
487  return 0;
488 }
489 
490 static int query_codec(enum AVCodecID id, int std_compliance)
491 {
493  while(cm->id != AV_CODEC_ID_NONE) {
494  if(id == cm->id)
495  return MKTAG('A', 'P', 'I', 'C');
496  cm++;
497  }
498  return -1;
499 }
500 
501 static const AVOption options[] = {
502  { "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
503  offsetof(MP3Context, id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 0, 4, AV_OPT_FLAG_ENCODING_PARAM},
504  { "write_id3v1", "Enable ID3v1 writing. ID3v1 tags are written in UTF-8 which may not be supported by most software.",
505  offsetof(MP3Context, write_id3v1), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
506  { "write_xing", "Write the Xing header containing file duration.",
507  offsetof(MP3Context, write_xing), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
508  { NULL },
509 };
510 
511 static const AVClass mp3_muxer_class = {
512  .class_name = "MP3 muxer",
513  .item_name = av_default_item_name,
514  .option = options,
515  .version = LIBAVUTIL_VERSION_INT,
516 };
517 
519 {
520  MP3Context *mp3 = s->priv_data;
521 
522  if (pkt->stream_index == mp3->audio_stream_idx) {
523  if (mp3->pics_to_write) {
524  /* buffer audio packets until we get all the pictures */
526 
527  if (ret < 0) {
528  av_log(s, AV_LOG_WARNING, "Not enough memory to buffer audio. Skipping picture streams\n");
529  mp3->pics_to_write = 0;
530  mp3_queue_flush(s);
531  return mp3_write_audio_packet(s, pkt);
532  }
533  } else
534  return mp3_write_audio_packet(s, pkt);
535  } else {
536  int ret;
537 
538  /* warn only once for each stream */
539  if (s->streams[pkt->stream_index]->nb_frames == 1) {
540  av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d,"
541  " ignoring.\n", pkt->stream_index);
542  }
543  if (!mp3->pics_to_write || s->streams[pkt->stream_index]->nb_frames >= 1)
544  return 0;
545 
546  if ((ret = ff_id3v2_write_apic(s, &mp3->id3, pkt)) < 0)
547  return ret;
548  mp3->pics_to_write--;
549 
550  /* flush the buffered audio packets */
551  if (!mp3->pics_to_write &&
552  (ret = mp3_queue_flush(s)) < 0)
553  return ret;
554  }
555 
556  return 0;
557 }
558 
559 /**
560  * Write an ID3v2 header at beginning of stream
561  */
562 
563 static int mp3_init(struct AVFormatContext *s)
564 {
565  MP3Context *mp3 = s->priv_data;
566  int i;
567 
568  if (mp3->id3v2_version &&
569  mp3->id3v2_version != 3 &&
570  mp3->id3v2_version != 4) {
571  av_log(s, AV_LOG_ERROR, "Invalid ID3v2 version requested: %d. Only "
572  "3, 4 or 0 (disabled) are allowed.\n", mp3->id3v2_version);
573  return AVERROR(EINVAL);
574  }
575 
576  /* check the streams -- we want exactly one audio and arbitrary number of
577  * video (attached pictures) */
578  mp3->audio_stream_idx = -1;
579  for (i = 0; i < s->nb_streams; i++) {
580  AVStream *st = s->streams[i];
581  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
582  if (mp3->audio_stream_idx >= 0 || st->codecpar->codec_id != AV_CODEC_ID_MP3) {
583  av_log(s, AV_LOG_ERROR, "Invalid audio stream. Exactly one MP3 "
584  "audio stream is required.\n");
585  return AVERROR(EINVAL);
586  }
587  mp3->audio_stream_idx = i;
588  } else if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
589  av_log(s, AV_LOG_ERROR, "Only audio streams and pictures are allowed in MP3.\n");
590  return AVERROR(EINVAL);
591  }
592  }
593  if (mp3->audio_stream_idx < 0) {
594  av_log(s, AV_LOG_ERROR, "No audio stream present.\n");
595  return AVERROR(EINVAL);
596  }
597  mp3->pics_to_write = s->nb_streams - 1;
598 
599  if (mp3->pics_to_write && !mp3->id3v2_version) {
600  av_log(s, AV_LOG_ERROR, "Attached pictures were requested, but the "
601  "ID3v2 header is disabled.\n");
602  return AVERROR(EINVAL);
603  }
604 
605  return 0;
606 }
607 
608 static int mp3_write_header(struct AVFormatContext *s)
609 {
610  MP3Context *mp3 = s->priv_data;
611  int ret;
612 
613  if (mp3->id3v2_version) {
615  ret = ff_id3v2_write_metadata(s, &mp3->id3);
616  if (ret < 0)
617  return ret;
618  }
619 
620  if (!mp3->pics_to_write) {
621  if (mp3->id3v2_version)
623  mp3_write_xing(s);
624  }
625 
626  return 0;
627 }
628 
629 static void mp3_deinit(struct AVFormatContext *s)
630 {
631  MP3Context *mp3 = s->priv_data;
632 
633  ff_packet_list_free(&mp3->queue, &mp3->queue_end);
634  av_freep(&mp3->xing_frame);
635 }
636 
638  .name = "mp3",
639  .long_name = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
640  .mime_type = "audio/mpeg",
641  .extensions = "mp3",
642  .priv_data_size = sizeof(MP3Context),
643  .audio_codec = AV_CODEC_ID_MP3,
644  .video_codec = AV_CODEC_ID_PNG,
645  .init = mp3_init,
649  .deinit = mp3_deinit,
652  .priv_class = &mp3_muxer_class,
653 };
#define MPA_STEREO
Definition: mpegaudio.h:46
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:701
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define XING_NUM_BAGS
Definition: mp3enc.c:92
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1401
AVOption.
Definition: opt.h:246
int ff_packet_list_put(AVPacketList **head, AVPacketList **tail, AVPacket *pkt, int flags)
Append an AVPacket to the list.
Definition: utils.c:441
void ff_id3v2_start(ID3v2EncContext *id3, AVIOContext *pb, int id3v2_version, const char *magic)
Initialize an ID3v2 tag.
Definition: id3v2enc.c:205
static int mp3_write_audio_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mp3enc.c:315
int64_t xing_frame_offset
Definition: mp3enc.c:113
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void ff_id3v2_finish(ID3v2EncContext *id3, AVIOContext *pb, int padding_bytes)
Finalize an opened ID3v2 tag.
Definition: id3v2enc.c:420
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint32_t pos
Definition: mp3enc.c:121
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int size
Definition: packet.h:356
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
const char * key
static AVPacket pkt
static void error(const char *err)
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1356
mpeg audio layer common tables.
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
uint64_t bag[XING_NUM_BAGS]
Definition: mp3enc.c:122
uint32_t track_peak
Peak track amplitude, with 100000 representing full scale (but values may overflow).
Definition: replaygain.h:39
uint8_t base
Definition: vp3data.h:202
Format I/O context.
Definition: avformat.h:1351
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
static void mp3_update_xing(AVFormatContext *s)
Definition: mp3enc.c:398
int32_t size
Definition: mp3enc.c:118
static int mp3_write_trailer(struct AVFormatContext *s)
Definition: mp3enc.c:468
uint8_t
int delay
Definition: mp3enc.c:125
AVOptions.
const uint16_t avpriv_mpa_freq_tab[3]
Definition: mpegaudiodata.c:40
uint8_t * av_stream_get_side_data(const AVStream *stream, enum AVPacketSideDataType type, int *size)
Get side information from stream.
Definition: utils.c:5498
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
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
#define FF_PACKETLIST_FLAG_REF_PACKET
Create a new reference for the packet instead of transferring the ownership of the existing one to th...
Definition: internal.h:733
Public header for CRC hash function implementation.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
uint8_t * data
Definition: packet.h:355
int avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header)
uint32_t tag
Definition: movenc.c:1532
static const uint8_t xing_offtbl[2][2]
Definition: mp3enc.c:137
enum AVCodecID id
Definition: internal.h:49
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
static const uint8_t header[24]
Definition: sdr2.c:67
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:213
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:58
channels
Definition: aptx.h:33
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AVCRC audio_crc
Definition: mp3enc.c:109
int32_t album_gain
Same as track_gain, but for the whole album.
Definition: replaygain.h:43
#define av_log(a,...)
#define cm
Definition: dvbsubdec.c:37
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
AVPacketList * queue_end
Definition: mp3enc.c:134
#define U(x)
Definition: vp56_arith.h:37
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1591
static const uint16_t mask[17]
Definition: lzw.c:38
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:352
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:410
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
simple assert() macros that are a bit more flexible than ISO C assert().
uint32_t want
Definition: mp3enc.c:119
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:94
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
int initial_bitrate
Definition: mp3enc.c:123
const CodecMime ff_id3v2_mime_tags[]
Definition: id3v2.c:131
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
static int mp3_write_xing(AVFormatContext *s)
Definition: mp3enc.c:142
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int ff_id3v2_write_metadata(AVFormatContext *s, ID3v2EncContext *id3)
Convert and write all global metadata from s into an ID3v2 tag.
Definition: id3v2enc.c:330
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:199
int id3v2_version
Definition: mp3enc.c:100
#define FFMIN(a, b)
Definition: common.h:96
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
static int mp3_init(struct AVFormatContext *s)
Write an ID3v2 header at beginning of stream.
Definition: mp3enc.c:563
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:465
const char * name
Definition: avformat.h:500
static int query_codec(enum AVCodecID id, int std_compliance)
Definition: mp3enc.c:490
int32_t
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
AVPacketList * queue
Definition: mp3enc.c:134
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rawenc.c:29
AVDictionary * metadata
Definition: avformat.h:940
int padding
Definition: mp3enc.c:126
int write_id3v1
Definition: mp3enc.c:101
#define FF_ARRAY_ELEMS(a)
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1851
Stream structure.
Definition: avformat.h:876
int pics_to_write
Definition: mp3enc.c:131
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
static const AVClass mp3_muxer_class
Definition: mp3enc.c:511
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
int has_variable_bitrate
Definition: mp3enc.c:124
int audio_stream_idx
Definition: mp3enc.c:129
int xing_offset
Definition: mp3enc.c:115
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
int32_t frames
Definition: mp3enc.c:117
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:191
static const AVOption options[]
Definition: mp3enc.c:501
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:604
int xing_frame_size
Definition: mp3enc.c:107
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
Recommmends skipping the specified number of samples.
Definition: packet.h:156
uint8_t * xing_frame
Definition: mp3enc.c:106
#define MPA_MONO
Definition: mpegaudio.h:49
void ff_packet_list_free(AVPacketList **head, AVPacketList **tail)
Wipe the list and unref all the packets in it.
Definition: utils.c:1423
#define XING_SIZE
Definition: mp3enc.c:95
uint32_t audio_size
Definition: mp3enc.c:110
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:453
#define flags(name, subs,...)
Definition: cbs_av1.c:564
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:99
static int id3v1_set_string(AVFormatContext *s, const char *key, uint8_t *buf, int buf_size)
Definition: mp3enc.c:39
int ff_id3v2_write_apic(AVFormatContext *s, ID3v2EncContext *id3, AVPacket *pkt)
Write an attached picture from pkt into an ID3v2 tag.
Definition: id3v2enc.c:351
int write_xing
Definition: mp3enc.c:102
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int sample_rate
Audio only.
Definition: codec_par.h:170
MPEG Audio header decoder.
int ff_packet_list_get(AVPacketList **head, AVPacketList **tail, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: utils.c:1553
static int mp3_queue_flush(AVFormatContext *s)
Definition: mp3enc.c:380
Main libavformat public API header.
AVOutputFormat ff_mp3_muxer
Definition: mp3enc.c:637
static int mp3_write_header(struct AVFormatContext *s)
Definition: mp3enc.c:608
mpeg audio declarations for both encoder and decoder.
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:927
#define MKBETAG(a, b, c, d)
Definition: common.h:407
static void mp3_deinit(struct AVFormatContext *s)
Definition: mp3enc.c:629
#define XING_TOC_SIZE
Definition: mp3enc.c:93
char * value
Definition: dict.h:87
void * priv_data
Format private data.
Definition: avformat.h:1379
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
int channels
Audio only.
Definition: codec_par.h:166
#define ID3v1_TAG_SIZE
Definition: id3v1.h:27
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
#define av_freep(p)
int32_t track_gain
Track replay gain in microbels (divide by 100000 to get the value in dB).
Definition: replaygain.h:34
const uint16_t avpriv_mpa_bitrate_tab[2][3][15]
Definition: mpegaudiodata.c:30
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
int stream_index
Definition: packet.h:357
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static int id3v1_create_tag(AVFormatContext *s, uint8_t *buf)
Definition: mp3enc.c:49
#define MKTAG(a, b, c, d)
Definition: common.h:406
ReplayGain information (see http://wiki.hydrogenaudio.org/index.php?title=ReplayGain_1.0_specification).
Definition: replaygain.h:29
static int mp3_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mp3enc.c:518
#define ID3v1_GENRE_MAX
Definition: id3v1.h:29
const char *const ff_id3v1_genre_str[ID3v1_GENRE_MAX+1]
ID3v1 genres.
Definition: id3v1.c:27
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:332
uint32_t AVCRC
Definition: crc.h:47
ID3v2EncContext id3
Definition: mp3enc.c:99
#define av_unused
Definition: attributes.h:131
static void mp3_xing_add_frame(MP3Context *mp3, AVPacket *pkt)
Definition: mp3enc.c:289
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
uint32_t seen
Definition: mp3enc.c:120