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 (!pb->seekable & AVIO_SEEKABLE_NORMAL)
53  return 0;
54 
55  if (!s->metadata && !aiff->pict_list)
56  return 0;
57 
58  avio_wl32(pb, MKTAG('I', 'D', '3', ' '));
59  avio_wb32(pb, 0);
60  pos = avio_tell(pb);
61 
63  ff_id3v2_write_metadata(s, &id3v2);
64  while (pict_list) {
65  if ((ret = ff_id3v2_write_apic(s, &id3v2, &pict_list->pkt)) < 0)
66  return ret;
67  pict_list = pict_list->next;
68  }
70 
71  end = avio_tell(pb);
72  size = end - pos;
73 
74  /* Update chunk size */
75  avio_seek(pb, pos - 4, SEEK_SET);
76  avio_wb32(pb, size);
77  avio_seek(pb, end, SEEK_SET);
78 
79  if (size & 1)
80  avio_w8(pb, 0);
81 
82  return 0;
83 }
84 
85 static void put_meta(AVFormatContext *s, const char *key, uint32_t id)
86 {
88  AVIOContext *pb = s->pb;
89 
90  if (tag = av_dict_get(s->metadata, key, NULL, 0)) {
91  int size = strlen(tag->value);
92 
93  avio_wl32(pb, id);
94  avio_wb32(pb, FFALIGN(size, 2));
95  avio_write(pb, tag->value, size);
96  if (size & 1)
97  avio_w8(pb, 0);
98  }
99 }
100 
102 {
103  AIFFOutputContext *aiff = s->priv_data;
104  AVIOContext *pb = s->pb;
105  AVCodecParameters *par;
106  uint64_t sample_rate;
107  int i, aifc = 0;
108 
109  aiff->audio_stream_idx = -1;
110  for (i = 0; i < s->nb_streams; i++) {
111  AVStream *st = s->streams[i];
112  if (aiff->audio_stream_idx < 0 && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
113  aiff->audio_stream_idx = i;
114  } else if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
115  av_log(s, AV_LOG_ERROR, "AIFF allows only one audio stream and a picture.\n");
116  return AVERROR(EINVAL);
117  }
118  }
119  if (aiff->audio_stream_idx < 0) {
120  av_log(s, AV_LOG_ERROR, "No audio stream present.\n");
121  return AVERROR(EINVAL);
122  }
123 
124  par = s->streams[aiff->audio_stream_idx]->codecpar;
125 
126  /* First verify if format is ok */
127  if (!par->codec_tag)
128  return -1;
129  if (par->codec_tag != MKTAG('N','O','N','E'))
130  aifc = 1;
131 
132  /* FORM AIFF header */
133  ffio_wfourcc(pb, "FORM");
134  aiff->form = avio_tell(pb);
135  avio_wb32(pb, 0); /* file length */
136  ffio_wfourcc(pb, aifc ? "AIFC" : "AIFF");
137 
138  if (aifc) { // compressed audio
139  if (!par->block_align) {
140  av_log(s, AV_LOG_ERROR, "block align not set\n");
141  return -1;
142  }
143  /* Version chunk */
144  ffio_wfourcc(pb, "FVER");
145  avio_wb32(pb, 4);
146  avio_wb32(pb, 0xA2805140);
147  }
148 
149  if (par->channels > 2 && par->channel_layout) {
150  ffio_wfourcc(pb, "CHAN");
151  avio_wb32(pb, 12);
153  }
154 
155  put_meta(s, "title", MKTAG('N', 'A', 'M', 'E'));
156  put_meta(s, "author", MKTAG('A', 'U', 'T', 'H'));
157  put_meta(s, "copyright", MKTAG('(', 'c', ')', ' '));
158  put_meta(s, "comment", MKTAG('A', 'N', 'N', 'O'));
159 
160  /* Common chunk */
161  ffio_wfourcc(pb, "COMM");
162  avio_wb32(pb, aifc ? 24 : 18); /* size */
163  avio_wb16(pb, par->channels); /* Number of channels */
164 
165  aiff->frames = avio_tell(pb);
166  avio_wb32(pb, 0); /* Number of frames */
167 
168  if (!par->bits_per_coded_sample)
170  if (!par->bits_per_coded_sample) {
171  av_log(s, AV_LOG_ERROR, "could not compute bits per sample\n");
172  return -1;
173  }
174  if (!par->block_align)
175  par->block_align = (par->bits_per_coded_sample * par->channels) >> 3;
176 
177  avio_wb16(pb, par->bits_per_coded_sample); /* Sample size */
178 
179  sample_rate = av_double2int(par->sample_rate);
180  avio_wb16(pb, (sample_rate >> 52) + (16383 - 1023));
181  avio_wb64(pb, UINT64_C(1) << 63 | sample_rate << 11);
182 
183  if (aifc) {
184  avio_wl32(pb, par->codec_tag);
185  avio_wb16(pb, 0);
186  }
187 
188  if ( (par->codec_tag == MKTAG('Q','D','M','2')
189  || par->codec_tag == MKTAG('Q','c','l','p')) && par->extradata_size) {
190  ffio_wfourcc(pb, "wave");
191  avio_wb32(pb, par->extradata_size);
192  avio_write(pb, par->extradata, par->extradata_size);
193  }
194 
195  /* Sound data chunk */
196  ffio_wfourcc(pb, "SSND");
197  aiff->ssnd = avio_tell(pb); /* Sound chunk size */
198  avio_wb32(pb, 0); /* Sound samples data size */
199  avio_wb32(pb, 0); /* Data offset */
200  avio_wb32(pb, 0); /* Block-size (block align) */
201 
204 
205  /* Data is starting here */
206  avio_flush(pb);
207 
208  return 0;
209 }
210 
212 {
213  AIFFOutputContext *aiff = s->priv_data;
214  AVIOContext *pb = s->pb;
215  if (pkt->stream_index == aiff->audio_stream_idx)
216  avio_write(pb, pkt->data, pkt->size);
217  else {
218  int ret;
219  AVPacketList *pict_list, *last;
220 
222  return 0;
223 
224  /* warn only once for each stream */
225  if (s->streams[pkt->stream_index]->nb_frames == 1) {
226  av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d,"
227  " ignoring.\n", pkt->stream_index);
228  }
229  if (s->streams[pkt->stream_index]->nb_frames >= 1)
230  return 0;
231 
232  pict_list = av_mallocz(sizeof(AVPacketList));
233  if (!pict_list)
234  return AVERROR(ENOMEM);
235 
236  ret = av_packet_ref(&pict_list->pkt, pkt);
237  if (ret < 0) {
238  av_freep(&pict_list);
239  return ret;
240  }
241 
242  if (!aiff->pict_list)
243  aiff->pict_list = pict_list;
244  else {
245  last = aiff->pict_list;
246  while (last->next)
247  last = last->next;
248  last->next = pict_list;
249  }
250  }
251 
252  return 0;
253 }
254 
256 {
257  int ret;
258  AVIOContext *pb = s->pb;
259  AIFFOutputContext *aiff = s->priv_data;
262 
263  /* Chunks sizes must be even */
264  int64_t file_size, end_size;
265  end_size = file_size = avio_tell(pb);
266  if (file_size & 1) {
267  avio_w8(pb, 0);
268  end_size++;
269  }
270 
271  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
272  /* Number of sample frames */
273  avio_seek(pb, aiff->frames, SEEK_SET);
274  avio_wb32(pb, (file_size - aiff->ssnd - 12) / par->block_align);
275 
276  /* Sound Data chunk size */
277  avio_seek(pb, aiff->ssnd, SEEK_SET);
278  avio_wb32(pb, file_size - aiff->ssnd - 4);
279 
280  /* return to the end */
281  avio_seek(pb, end_size, SEEK_SET);
282 
283  /* Write ID3 tags */
284  if (aiff->write_id3v2)
285  if ((ret = put_id3v2_tags(s, aiff)) < 0)
286  return ret;
287 
288  /* File length */
289  file_size = avio_tell(pb);
290  avio_seek(pb, aiff->form, SEEK_SET);
291  avio_wb32(pb, file_size - aiff->form - 4);
292 
293  avio_flush(pb);
294  }
295 
296  while (pict_list) {
297  AVPacketList *next = pict_list->next;
298  av_packet_unref(&pict_list->pkt);
299  av_freep(&pict_list);
300  pict_list = next;
301  }
302 
303  return 0;
304 }
305 
306 #define OFFSET(x) offsetof(AIFFOutputContext, x)
307 #define ENC AV_OPT_FLAG_ENCODING_PARAM
308 static const AVOption options[] = {
309  { "write_id3v2", "Enable ID3 tags writing.",
310  OFFSET(write_id3v2), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, ENC },
311  { "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
312  OFFSET(id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 3, 4, ENC },
313  { NULL },
314 };
315 
316 static const AVClass aiff_muxer_class = {
317  .class_name = "AIFF muxer",
318  .item_name = av_default_item_name,
319  .option = options,
320  .version = LIBAVUTIL_VERSION_INT,
321 };
322 
324  .name = "aiff",
325  .long_name = NULL_IF_CONFIG_SMALL("Audio IFF"),
326  .mime_type = "audio/aiff",
327  .extensions = "aif,aiff,afc,aifc",
328  .priv_data_size = sizeof(AIFFOutputContext),
329  .audio_codec = AV_CODEC_ID_PCM_S16BE,
330  .video_codec = AV_CODEC_ID_PNG,
334  .codec_tag = (const AVCodecTag* const []){ ff_codec_aiff_tags, 0 },
335  .priv_class = &aiff_muxer_class,
336 };
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:689
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:463
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
AVOption.
Definition: opt.h:246
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:4886
static int aiff_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: aiffenc.c:211
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
int size
Definition: avcodec.h:1478
#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
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static AVPacket pkt
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3949
Format I/O context.
Definition: avformat.h:1358
#define ENC
Definition: aiffenc.c:307
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:369
AVOptions.
AVPacket pkt
Definition: avformat.h:2025
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
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:1477
uint32_t tag
Definition: movenc.c:1496
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:4059
#define av_log(a,...)
int audio_stream_idx
Definition: aiffenc.c:38
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:608
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:1513
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:3953
static const AVOption options[]
Definition: aiffenc.c:308
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
int block_align
Audio only.
Definition: avcodec.h:4074
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
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:255
#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:306
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
Describe the class of an AVClass context structure.
Definition: log.h:67
static int aiff_write_header(AVFormatContext *s)
Definition: aiffenc.c:101
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:475
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:4067
void ff_mov_write_chan(AVIOContext *pb, int64_t channel_layout)
Definition: isom.c:642
Main libavformat public API header.
static void put_meta(AVFormatContext *s, const char *key, uint32_t id)
Definition: aiffenc.c:85
struct AVPacketList * next
Definition: avformat.h:2026
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:316
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3999
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
int channels
Audio only.
Definition: avcodec.h:4063
common header for AIFF muxer and demuxer
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:377
#define av_freep(p)
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:3961
int stream_index
Definition: avcodec.h:1479
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:1454
int64_t form
Definition: aiffenc.c:35
AVOutputFormat ff_aiff_muxer
Definition: aiffenc.c:323