RepoMirrors/ffmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2024-12-24 00:02:52 +00:00
Code Issues Projects Releases Wiki Activity
a2c57e27d6
ffmpeg/libavformat/cafenc.c
Andreas Rheinhardt 790f793844 avutil/common: Don't auto-include mem.h 
There are lots of files that don't need it: The number of object
files that actually need it went down from 2011 to 884 here.

Keep it for external users in order to not cause breakages.

Also improve the other headers a bit while just at it.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2024-03-31 00:08:43 +01:00

290 lines
9.7 KiB
C
Raw Blame History

/*
* Core Audio Format muxer
* Copyright (c) 2011 Carl Eugen Hoyos
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avformat.h"
#include "caf.h"
#include "isom.h"
#include "avio_internal.h"
#include "mux.h"
#include "libavutil/intfloat.h"
#include "libavutil/dict.h"
#include "libavutil/mem.h"
#define FRAME_SIZE_OFFSET 40
typedef struct {
int64_t data;
int size_buffer_size;
int size_entries_used;
int packets;
} CAFContext;
static uint32_t codec_flags(enum AVCodecID codec_id) {
switch (codec_id) {
case AV_CODEC_ID_PCM_F32BE:
case AV_CODEC_ID_PCM_F64BE:
return 1; //< kCAFLinearPCMFormatFlagIsFloat
case AV_CODEC_ID_PCM_S16LE:
case AV_CODEC_ID_PCM_S24LE:
case AV_CODEC_ID_PCM_S32LE:
return 2; //< kCAFLinearPCMFormatFlagIsLittleEndian
case AV_CODEC_ID_PCM_F32LE:
case AV_CODEC_ID_PCM_F64LE:
return 3; //< kCAFLinearPCMFormatFlagIsFloat | kCAFLinearPCMFormatFlagIsLittleEndian
default:
return 0;
}
}
static uint32_t samples_per_packet(const AVCodecParameters *par) {
enum AVCodecID codec_id = par->codec_id;
int channels = par->ch_layout.nb_channels, block_align = par->block_align;
int frame_size = par->frame_size, sample_rate = par->sample_rate;
switch (codec_id) {
case AV_CODEC_ID_PCM_S8:
case AV_CODEC_ID_PCM_S16LE:
case AV_CODEC_ID_PCM_S16BE:
case AV_CODEC_ID_PCM_S24LE:
case AV_CODEC_ID_PCM_S24BE:
case AV_CODEC_ID_PCM_S32LE:
case AV_CODEC_ID_PCM_S32BE:
case AV_CODEC_ID_PCM_F32LE:
case AV_CODEC_ID_PCM_F32BE:
case AV_CODEC_ID_PCM_F64LE:
case AV_CODEC_ID_PCM_F64BE:
case AV_CODEC_ID_PCM_ALAW:
case AV_CODEC_ID_PCM_MULAW:
return 1;
case AV_CODEC_ID_MACE3:
case AV_CODEC_ID_MACE6:
return 6;
case AV_CODEC_ID_ADPCM_IMA_QT:
return 64;
case AV_CODEC_ID_AMR_NB:
case AV_CODEC_ID_GSM:
case AV_CODEC_ID_ILBC:
case AV_CODEC_ID_QCELP:
return 160;
case AV_CODEC_ID_GSM_MS:
return 320;
case AV_CODEC_ID_MP1:
return 384;
case AV_CODEC_ID_OPUS:
return frame_size * 48000 / sample_rate;
case AV_CODEC_ID_MP2:
case AV_CODEC_ID_MP3:
return 1152;
case AV_CODEC_ID_AC3:
return 1536;
case AV_CODEC_ID_QDM2:
case AV_CODEC_ID_QDMC:
return 2048 * channels;
case AV_CODEC_ID_ALAC:
return 4096;
case AV_CODEC_ID_ADPCM_IMA_WAV:
return (block_align - 4 * channels) * 8 / (4 * channels) + 1;
case AV_CODEC_ID_ADPCM_MS:
return (block_align - 7 * channels) * 2 / channels + 2;
default:
return 0;
}
}
static int caf_write_header(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
AVCodecParameters *par = s->streams[0]->codecpar;
CAFContext *caf = s->priv_data;
const AVDictionaryEntry *t = NULL;
unsigned int codec_tag = ff_codec_get_tag(ff_codec_caf_tags, par->codec_id);
int64_t chunk_size = 0;
int frame_size = par->frame_size, sample_rate = par->sample_rate;
switch (par->codec_id) {
case AV_CODEC_ID_AAC:
av_log(s, AV_LOG_ERROR, "muxing codec currently unsupported\n");
return AVERROR_PATCHWELCOME;
}
if (par->codec_id == AV_CODEC_ID_OPUS && par->ch_layout.nb_channels > 2) {
av_log(s, AV_LOG_ERROR, "Only mono and stereo are supported for Opus\n");
return AVERROR_INVALIDDATA;
}
if (!codec_tag) {
av_log(s, AV_LOG_ERROR, "unsupported codec\n");
return AVERROR_INVALIDDATA;
}
if (!par->block_align && !(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
av_log(s, AV_LOG_ERROR, "Muxing variable packet size not supported on non seekable output\n");
return AVERROR_INVALIDDATA;
}
if (par->codec_id != AV_CODEC_ID_MP3 || frame_size != 576)
frame_size = samples_per_packet(par);
if (par->codec_id == AV_CODEC_ID_OPUS)
sample_rate = 48000;
ffio_wfourcc(pb, "caff"); //< mFileType
avio_wb16(pb, 1); //< mFileVersion
avio_wb16(pb, 0); //< mFileFlags
ffio_wfourcc(pb, "desc"); //< Audio Description chunk
avio_wb64(pb, 32); //< mChunkSize
avio_wb64(pb, av_double2int(sample_rate)); //< mSampleRate
avio_wl32(pb, codec_tag); //< mFormatID
avio_wb32(pb, codec_flags(par->codec_id)); //< mFormatFlags
avio_wb32(pb, par->block_align); //< mBytesPerPacket
avio_wb32(pb, frame_size); //< mFramesPerPacket
avio_wb32(pb, par->ch_layout.nb_channels); //< mChannelsPerFrame
avio_wb32(pb, av_get_bits_per_sample(par->codec_id)); //< mBitsPerChannel
if (par->ch_layout.order == AV_CHANNEL_ORDER_NATIVE) {
ffio_wfourcc(pb, "chan");
avio_wb64(pb, 12);
ff_mov_write_chan(pb, par->ch_layout.u.mask);
}
if (par->codec_id == AV_CODEC_ID_ALAC) {
ffio_wfourcc(pb, "kuki");
avio_wb64(pb, 12 + par->extradata_size);
avio_write(pb, "\0\0\0\14frmaalac", 12);
avio_write(pb, par->extradata, par->extradata_size);
} else if (par->codec_id == AV_CODEC_ID_AMR_NB) {
ffio_wfourcc(pb, "kuki");
avio_wb64(pb, 29);
avio_write(pb, "\0\0\0\14frmasamr", 12);
avio_wb32(pb, 0x11); /* size */
avio_write(pb, "samrFFMP", 8);
avio_w8(pb, 0); /* decoder version */
avio_wb16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */
avio_w8(pb, 0x00); /* Mode change period (no restriction) */
avio_w8(pb, 0x01); /* Frames per sample */
} else if (par->codec_id == AV_CODEC_ID_QDM2 || par->codec_id == AV_CODEC_ID_QDMC) {
ffio_wfourcc(pb, "kuki");
avio_wb64(pb, par->extradata_size);
avio_write(pb, par->extradata, par->extradata_size);
}
ff_standardize_creation_time(s);
if (av_dict_count(s->metadata)) {
ffio_wfourcc(pb, "info"); //< Information chunk
while ((t = av_dict_iterate(s->metadata, t))) {
chunk_size += strlen(t->key) + strlen(t->value) + 2;
}
avio_wb64(pb, chunk_size + 4);
avio_wb32(pb, av_dict_count(s->metadata));
t = NULL;
while ((t = av_dict_iterate(s->metadata, t))) {
avio_put_str(pb, t->key);
avio_put_str(pb, t->value);
}
}
ffio_wfourcc(pb, "data"); //< Audio Data chunk
caf->data = avio_tell(pb);
avio_wb64(pb, -1); //< mChunkSize
avio_wb32(pb, 0); //< mEditCount
return 0;
}
static int caf_write_packet(AVFormatContext *s, AVPacket *pkt)
{
CAFContext *caf = s->priv_data;
AVStream *const st = s->streams[0];
if (!st->codecpar->block_align) {
uint8_t *pkt_sizes;
int i, alloc_size = caf->size_entries_used + 5U;
if (alloc_size < 0)
return AVERROR(ERANGE);
pkt_sizes = av_fast_realloc(st->priv_data,
&caf->size_buffer_size,
alloc_size);
if (!pkt_sizes)
return AVERROR(ENOMEM);
st->priv_data = pkt_sizes;
for (i = 4; i > 0; i--) {
unsigned top = pkt->size >> i * 7;
if (top)
pkt_sizes[caf->size_entries_used++] = 128 | top;
}
pkt_sizes[caf->size_entries_used++] = pkt->size & 127;
caf->packets++;
}
avio_write(s->pb, pkt->data, pkt->size);
return 0;
}
static int caf_write_trailer(AVFormatContext *s)
{
CAFContext *caf = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st = s->streams[0];
AVCodecParameters *par = st->codecpar;
if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
int64_t file_size = avio_tell(pb);
avio_seek(pb, caf->data, SEEK_SET);
avio_wb64(pb, file_size - caf->data - 8);
if (!par->block_align) {
int packet_size = samples_per_packet(par);
if (!packet_size) {
packet_size = st->duration / (caf->packets - 1);
avio_seek(pb, FRAME_SIZE_OFFSET, SEEK_SET);
avio_wb32(pb, packet_size);
}
avio_seek(pb, file_size, SEEK_SET);
ffio_wfourcc(pb, "pakt");
avio_wb64(pb, caf->size_entries_used + 24U);
avio_wb64(pb, caf->packets); ///< mNumberPackets
avio_wb64(pb, caf->packets * packet_size); ///< mNumberValidFrames
avio_wb32(pb, 0); ///< mPrimingFrames
avio_wb32(pb, 0); ///< mRemainderFrames
avio_write(pb, st->priv_data, caf->size_entries_used);
}
}
return 0;
}
const FFOutputFormat ff_caf_muxer = {
.p.name = "caf",
.p.long_name = NULL_IF_CONFIG_SMALL("Apple CAF (Core Audio Format)"),
.p.mime_type = "audio/x-caf",
.p.extensions = "caf",
.priv_data_size = sizeof(CAFContext),
.p.audio_codec = AV_CODEC_ID_PCM_S16BE,
.p.video_codec = AV_CODEC_ID_NONE,
.p.subtitle_codec = AV_CODEC_ID_NONE,
.flags_internal = FF_OFMT_FLAG_MAX_ONE_OF_EACH,
.write_header = caf_write_header,
.write_packet = caf_write_packet,
.write_trailer = caf_write_trailer,
.p.codec_tag = ff_caf_codec_tags_list,
};
Reference in New Issue View Git Blame Copy Permalink