FFmpeg
aiffenc.c
Go to the documentation of this file.
1 /*
2  * AIFF/AIFF-C muxer
3  * Copyright (c) 2006 Patrick Guimond
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 <stdint.h>
23 
24 #include "libavutil/intfloat.h"
25 #include "libavutil/opt.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "aiff.h"
29 #include "avio_internal.h"
30 #include "isom.h"
31 #include "id3v2.h"
32 
33 typedef struct AIFFOutputContext {
34  const AVClass *class;
35  int64_t form;
36  int64_t frames;
37  int64_t ssnd;
43 
45 {
46  int ret;
47  uint64_t pos, end, size;
48  ID3v2EncContext id3v2 = { 0 };
49  AVIOContext *pb = s->pb;
51 
52  if (!s->metadata && !aiff->pict_list)
53  return 0;
54 
55  avio_wl32(pb, MKTAG('I', 'D', '3', ' '));
56  avio_wb32(pb, 0);
57  pos = avio_tell(pb);
58 
60  ff_id3v2_write_metadata(s, &id3v2);
61  while (pict_list) {
62  if ((ret = ff_id3v2_write_apic(s, &id3v2, &pict_list->pkt)) < 0)
63  return ret;
64  pict_list = pict_list->next;
65  }
67 
68  end = avio_tell(pb);
69  size = end - pos;
70 
71  /* Update chunk size */
72  avio_seek(pb, pos - 4, SEEK_SET);
73  avio_wb32(pb, size);
74  avio_seek(pb, end, SEEK_SET);
75 
76  if (size & 1)
77  avio_w8(pb, 0);
78 
79  return 0;
80 }
81 
82 static void put_meta(AVFormatContext *s, const char *key, uint32_t id)
83 {
85  AVIOContext *pb = s->pb;
86 
87  if (tag = av_dict_get(s->metadata, key, NULL, 0)) {
88  int size = strlen(tag->value);
89 
90  avio_wl32(pb, id);
91  avio_wb32(pb, FFALIGN(size, 2));
92  avio_write(pb, tag->value, size);
93  if (size & 1)
94  avio_w8(pb, 0);
95  }
96 }
97 
99 {
100  AIFFOutputContext *aiff = s->priv_data;
101  AVIOContext *pb = s->pb;
102  AVCodecParameters *par;
103  uint64_t sample_rate;
104  int i, aifc = 0;
105 
106  aiff->audio_stream_idx = -1;
107  for (i = 0; i < s->nb_streams; i++) {
108  AVStream *st = s->streams[i];
109  if (aiff->audio_stream_idx < 0 && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
110  aiff->audio_stream_idx = i;
111  } else if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
112  av_log(s, AV_LOG_ERROR, "AIFF allows only one audio stream and a picture.\n");
113  return AVERROR(EINVAL);
114  }
115  }
116  if (aiff->audio_stream_idx < 0) {
117  av_log(s, AV_LOG_ERROR, "No audio stream present.\n");
118  return AVERROR(EINVAL);
119  }
120 
121  par = s->streams[aiff->audio_stream_idx]->codecpar;
122 
123  /* First verify if format is ok */
124  if (!par->codec_tag)
125  return AVERROR(EINVAL);
126  if (par->codec_tag != MKTAG('N','O','N','E'))
127  aifc = 1;
128 
129  /* FORM AIFF header */
130  ffio_wfourcc(pb, "FORM");
131  aiff->form = avio_tell(pb);
132  avio_wb32(pb, 0); /* file length */
133  ffio_wfourcc(pb, aifc ? "AIFC" : "AIFF");
134 
135  if (aifc) { // compressed audio
136  if (!par->block_align) {
137  av_log(s, AV_LOG_ERROR, "block align not set\n");
138  return AVERROR(EINVAL);
139  }
140  /* Version chunk */
141  ffio_wfourcc(pb, "FVER");
142  avio_wb32(pb, 4);
143  avio_wb32(pb, 0xA2805140);
144  }
145 
146  if (par->channels > 2 && par->channel_layout) {
147  ffio_wfourcc(pb, "CHAN");
148  avio_wb32(pb, 12);
150  }
151 
152  put_meta(s, "title", MKTAG('N', 'A', 'M', 'E'));
153  put_meta(s, "author", MKTAG('A', 'U', 'T', 'H'));
154  put_meta(s, "copyright", MKTAG('(', 'c', ')', ' '));
155  put_meta(s, "comment", MKTAG('A', 'N', 'N', 'O'));
156 
157  /* Common chunk */
158  ffio_wfourcc(pb, "COMM");
159  avio_wb32(pb, aifc ? 24 : 18); /* size */
160  avio_wb16(pb, par->channels); /* Number of channels */
161 
162  aiff->frames = avio_tell(pb);
163  avio_wb32(pb, 0); /* Number of frames */
164 
165  if (!par->bits_per_coded_sample)
167  if (!par->bits_per_coded_sample) {
168  av_log(s, AV_LOG_ERROR, "could not compute bits per sample\n");
169  return AVERROR(EINVAL);
170  }
171  if (!par->block_align)
172  par->block_align = (par->bits_per_coded_sample * par->channels) >> 3;
173 
174  avio_wb16(pb, par->bits_per_coded_sample); /* Sample size */
175 
176  sample_rate = av_double2int(par->sample_rate);
177  avio_wb16(pb, (sample_rate >> 52) + (16383 - 1023));
178  avio_wb64(pb, UINT64_C(1) << 63 | sample_rate << 11);
179 
180  if (aifc) {
181  avio_wl32(pb, par->codec_tag);
182  avio_wb16(pb, 0);
183  }
184 
185  if ( (par->codec_tag == MKTAG('Q','D','M','2')
186  || par->codec_tag == MKTAG('Q','c','l','p')) && par->extradata_size) {
187  ffio_wfourcc(pb, "wave");
188  avio_wb32(pb, par->extradata_size);
189  avio_write(pb, par->extradata, par->extradata_size);
190  }
191 
192  /* Sound data chunk */
193  ffio_wfourcc(pb, "SSND");
194  aiff->ssnd = avio_tell(pb); /* Sound chunk size */
195  avio_wb32(pb, 0); /* Sound samples data size */
196  avio_wb32(pb, 0); /* Data offset */
197  avio_wb32(pb, 0); /* Block-size (block align) */
198 
201 
202  /* Data is starting here */
203  avio_flush(pb);
204 
205  return 0;
206 }
207 
209 {
210  AIFFOutputContext *aiff = s->priv_data;
211  AVIOContext *pb = s->pb;
212  if (pkt->stream_index == aiff->audio_stream_idx)
213  avio_write(pb, pkt->data, pkt->size);
214  else {
216  return 0;
217 
218  /* warn only once for each stream */
219  if (s->streams[pkt->stream_index]->nb_frames == 1) {
220  av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d,"
221  " ignoring.\n", pkt->stream_index);
222  }
223  if (s->streams[pkt->stream_index]->nb_frames >= 1)
224  return 0;
225 
226  return ff_packet_list_put(&aiff->pict_list, &aiff->pict_list_end,
228  }
229 
230  return 0;
231 }
232 
234 {
235  int ret = 0;
236  AVIOContext *pb = s->pb;
237  AIFFOutputContext *aiff = s->priv_data;
239 
240  /* Chunks sizes must be even */
241  int64_t file_size, end_size;
242  end_size = file_size = avio_tell(pb);
243  if (file_size & 1) {
244  avio_w8(pb, 0);
245  end_size++;
246  }
247 
248  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
249  /* Number of sample frames */
250  avio_seek(pb, aiff->frames, SEEK_SET);
251  avio_wb32(pb, (file_size - aiff->ssnd - 12) / par->block_align);
252 
253  /* Sound Data chunk size */
254  avio_seek(pb, aiff->ssnd, SEEK_SET);
255  avio_wb32(pb, file_size - aiff->ssnd - 4);
256 
257  /* return to the end */
258  avio_seek(pb, end_size, SEEK_SET);
259 
260  /* Write ID3 tags */
261  if (aiff->write_id3v2)
262  if ((ret = put_id3v2_tags(s, aiff)) < 0)
263  return ret;
264 
265  /* File length */
266  file_size = avio_tell(pb);
267  avio_seek(pb, aiff->form, SEEK_SET);
268  avio_wb32(pb, file_size - aiff->form - 4);
269 
270  avio_flush(pb);
271  }
272 
273  return ret;
274 }
275 
277 {
278  AIFFOutputContext *aiff = s->priv_data;
279 
281 }
282 
283 #define OFFSET(x) offsetof(AIFFOutputContext, x)
284 #define ENC AV_OPT_FLAG_ENCODING_PARAM
285 static const AVOption options[] = {
286  { "write_id3v2", "Enable ID3 tags writing.",
287  OFFSET(write_id3v2), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, ENC },
288  { "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
289  OFFSET(id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 3, 4, ENC },
290  { NULL },
291 };
292 
293 static const AVClass aiff_muxer_class = {
294  .class_name = "AIFF muxer",
295  .item_name = av_default_item_name,
296  .option = options,
297  .version = LIBAVUTIL_VERSION_INT,
298 };
299 
301  .name = "aiff",
302  .long_name = NULL_IF_CONFIG_SMALL("Audio IFF"),
303  .mime_type = "audio/aiff",
304  .extensions = "aif,aiff,afc,aifc",
305  .priv_data_size = sizeof(AIFFOutputContext),
306  .audio_codec = AV_CODEC_ID_PCM_S16BE,
307  .video_codec = AV_CODEC_ID_PNG,
311  .deinit = aiff_deinit,
312  .codec_tag = (const AVCodecTag* const []){ ff_codec_aiff_tags, 0 },
313  .priv_class = &aiff_muxer_class,
314 };
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:690
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:466
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
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:447
void ff_id3v2_start(ID3v2EncContext *id3, AVIOContext *pb, int id3v2_version, const char *magic)
Initialize an ID3v2 tag.
Definition: id3v2enc.c:205
#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:425
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4929
static int aiff_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: aiffenc.c:208
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
AVPacketList * pict_list_end
Definition: aiffenc.c:39
int size
Definition: avcodec.h:1481
#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:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
Definition: intfloat.h:70
const char * key
static AVPacket pkt
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3960
Format I/O context.
Definition: avformat.h:1358
#define ENC
Definition: aiffenc.c:284
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
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:372
AVOptions.
AVPacket pkt
Definition: avformat.h:2032
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
#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:755
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: avcodec.h:1480
uint32_t tag
Definition: movenc.c:1531
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:58
#define FFALIGN(x, a)
Definition: macros.h:48
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4070
#define av_log(a,...)
int audio_stream_idx
Definition: aiffenc.c:38
int64_t frames
Definition: aiffenc.c:36
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1533
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
static const AVOption options[]
Definition: aiffenc.c:285
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3986
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
int block_align
Audio only.
Definition: avcodec.h:4085
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:335
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
const char * name
Definition: avformat.h:505
static int aiff_write_trailer(AVFormatContext *s)
Definition: aiffenc.c:233
#define s(width, name)
Definition: cbs_vp9.c:257
AVPacketList * pict_list
Definition: aiffenc.c:39
static int put_id3v2_tags(AVFormatContext *s, AIFFOutputContext *aiff)
Definition: aiffenc.c:44
int metadata_header_padding
Number of bytes to be written as padding in a metadata header.
Definition: avformat.h:1858
Stream structure.
Definition: avformat.h:881
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
sample_rate
int64_t ssnd
Definition: aiffenc.c:37
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
#define OFFSET(x)
Definition: aiffenc.c:283
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
Describe the class of an AVClass context structure.
Definition: log.h:67
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
void ff_packet_list_free(AVPacketList **head, AVPacketList **tail)
Wipe the list and unref all the packets in it.
Definition: utils.c:1427
static int aiff_write_header(AVFormatContext *s)
Definition: aiffenc.c:98
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:478
int ff_id3v2_write_apic(AVFormatContext *s, ID3v2EncContext *id3, AVPacket *pkt)
Write an attached picture from pkt into an ID3v2 tag.
Definition: id3v2enc.c:356
int sample_rate
Audio only.
Definition: avcodec.h:4078
void ff_mov_write_chan(AVIOContext *pb, int64_t channel_layout)
Definition: isom.c:643
Main libavformat public API header.
static void put_meta(AVFormatContext *s, const char *key, uint32_t id)
Definition: aiffenc.c:82
static void aiff_deinit(AVFormatContext *s)
Definition: aiffenc.c:276
struct AVPacketList * next
Definition: avformat.h:2033
static const AVCodecTag ff_codec_aiff_tags[]
Definition: aiff.h:33
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:932
char * value
Definition: dict.h:87
void * priv_data
Format private data.
Definition: avformat.h:1386
static const AVClass aiff_muxer_class
Definition: aiffenc.c:293
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:349
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4010
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3982
int channels
Audio only.
Definition: avcodec.h:4074
common header for AIFF muxer and demuxer
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:380
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3972
int stream_index
Definition: avcodec.h:1482
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1457
int64_t form
Definition: aiffenc.c:35
AVOutputFormat ff_aiff_muxer
Definition: aiffenc.c:300