FFmpeg: libavformat/cafenc.c Source File

00001 /*
00002  * Core Audio Format muxer
00003  * Copyright (c) 2011 Carl Eugen Hoyos
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00022 #include "avformat.h"
00023 #include "caf.h"
00024 #include "isom.h"
00025 #include "avio_internal.h"
00026 #include "libavutil/intfloat.h"
00027 #include "libavutil/dict.h"
00028 
00029 typedef struct {
00030     int64_t data;
00031     uint8_t *pkt_sizes;
00032     int size_buffer_size;
00033     int size_entries_used;
00034     int packets;
00035 } CAFContext;
00036 
00037 static uint32_t codec_flags(enum AVCodecID codec_id) {
00038     switch (codec_id) {
00039     case AV_CODEC_ID_PCM_F32BE:
00040     case AV_CODEC_ID_PCM_F64BE:
00041         return 1; //< kCAFLinearPCMFormatFlagIsFloat
00042     case AV_CODEC_ID_PCM_S16LE:
00043     case AV_CODEC_ID_PCM_S24LE:
00044     case AV_CODEC_ID_PCM_S32LE:
00045         return 2; //< kCAFLinearPCMFormatFlagIsLittleEndian
00046     case AV_CODEC_ID_PCM_F32LE:
00047     case AV_CODEC_ID_PCM_F64LE:
00048         return 3; //< kCAFLinearPCMFormatFlagIsFloat | kCAFLinearPCMFormatFlagIsLittleEndian
00049     default:
00050         return 0;
00051     }
00052 }
00053 
00054 static uint32_t samples_per_packet(enum AVCodecID codec_id, int channels) {
00055     switch (codec_id) {
00056     case AV_CODEC_ID_PCM_S8:
00057     case AV_CODEC_ID_PCM_S16LE:
00058     case AV_CODEC_ID_PCM_S16BE:
00059     case AV_CODEC_ID_PCM_S24LE:
00060     case AV_CODEC_ID_PCM_S24BE:
00061     case AV_CODEC_ID_PCM_S32LE:
00062     case AV_CODEC_ID_PCM_S32BE:
00063     case AV_CODEC_ID_PCM_F32LE:
00064     case AV_CODEC_ID_PCM_F32BE:
00065     case AV_CODEC_ID_PCM_F64LE:
00066     case AV_CODEC_ID_PCM_F64BE:
00067     case AV_CODEC_ID_PCM_ALAW:
00068     case AV_CODEC_ID_PCM_MULAW:
00069         return 1;
00070     case AV_CODEC_ID_MACE3:
00071     case AV_CODEC_ID_MACE6:
00072         return 6;
00073     case AV_CODEC_ID_ADPCM_IMA_QT:
00074         return 64;
00075     case AV_CODEC_ID_AMR_NB:
00076     case AV_CODEC_ID_GSM:
00077     case AV_CODEC_ID_ILBC:
00078     case AV_CODEC_ID_QCELP:
00079         return 160;
00080     case AV_CODEC_ID_GSM_MS:
00081         return 320;
00082     case AV_CODEC_ID_MP1:
00083         return 384;
00084     case AV_CODEC_ID_MP2:
00085     case AV_CODEC_ID_MP3:
00086         return 1152;
00087     case AV_CODEC_ID_AC3:
00088         return 1536;
00089     case AV_CODEC_ID_ALAC:
00090     case AV_CODEC_ID_QDM2:
00091         return 4096;
00092     case AV_CODEC_ID_ADPCM_IMA_WAV:
00093         return (1024 - 4 * channels) * 8 / (4 * channels) + 1;
00094     case AV_CODEC_ID_ADPCM_MS:
00095         return (1024 - 7 * channels) * 2 / channels + 2;
00096     default:
00097         return 0;
00098     }
00099 }
00100 
00101 static int caf_write_header(AVFormatContext *s)
00102 {
00103     AVIOContext *pb = s->pb;
00104     AVCodecContext *enc = s->streams[0]->codec;
00105     CAFContext *caf = s->priv_data;
00106     AVDictionaryEntry *t = NULL;
00107     unsigned int codec_tag = ff_codec_get_tag(ff_codec_caf_tags, enc->codec_id);
00108     int64_t chunk_size = 0;
00109 
00110     switch (enc->codec_id) {
00111     case AV_CODEC_ID_AAC:
00112     case AV_CODEC_ID_AC3:
00113         av_log(s, AV_LOG_ERROR, "muxing codec currently unsupported\n");
00114         return AVERROR_PATCHWELCOME;
00115     }
00116 
00117     switch (enc->codec_id) {
00118     case AV_CODEC_ID_PCM_S8:
00119     case AV_CODEC_ID_PCM_S16LE:
00120     case AV_CODEC_ID_PCM_S16BE:
00121     case AV_CODEC_ID_PCM_S24LE:
00122     case AV_CODEC_ID_PCM_S24BE:
00123     case AV_CODEC_ID_PCM_S32LE:
00124     case AV_CODEC_ID_PCM_S32BE:
00125     case AV_CODEC_ID_PCM_F32LE:
00126     case AV_CODEC_ID_PCM_F32BE:
00127     case AV_CODEC_ID_PCM_F64LE:
00128     case AV_CODEC_ID_PCM_F64BE:
00129     case AV_CODEC_ID_PCM_ALAW:
00130     case AV_CODEC_ID_PCM_MULAW:
00131         codec_tag = MKTAG('l','p','c','m');
00132     }
00133 
00134     if (!codec_tag) {
00135         av_log(s, AV_LOG_ERROR, "unsupported codec\n");
00136         return AVERROR_INVALIDDATA;
00137     }
00138 
00139     if (!enc->block_align && !pb->seekable) {
00140         av_log(s, AV_LOG_ERROR, "Muxing variable packet size not supported on non seekable output\n");
00141         return AVERROR_INVALIDDATA;
00142     }
00143 
00144     ffio_wfourcc(pb, "caff"); //< mFileType
00145     avio_wb16(pb, 1);         //< mFileVersion
00146     avio_wb16(pb, 0);         //< mFileFlags
00147 
00148     ffio_wfourcc(pb, "desc");                         //< Audio Description chunk
00149     avio_wb64(pb, 32);                                //< mChunkSize
00150     avio_wb64(pb, av_double2int(enc->sample_rate));   //< mSampleRate
00151     avio_wl32(pb, codec_tag);                         //< mFormatID
00152     avio_wb32(pb, codec_flags(enc->codec_id));        //< mFormatFlags
00153     avio_wb32(pb, enc->block_align);                  //< mBytesPerPacket
00154     avio_wb32(pb, samples_per_packet(enc->codec_id, enc->channels)); //< mFramesPerPacket
00155     avio_wb32(pb, enc->channels);                     //< mChannelsPerFrame
00156     avio_wb32(pb, av_get_bits_per_sample(enc->codec_id)); //< mBitsPerChannel
00157 
00158     if (enc->channel_layout) {
00159         ffio_wfourcc(pb, "chan");
00160         avio_wb64(pb, 12);
00161         ff_mov_write_chan(pb, enc->channel_layout);
00162     }
00163 
00164     if (enc->codec_id == AV_CODEC_ID_ALAC) {
00165         ffio_wfourcc(pb, "kuki");
00166         avio_wb64(pb, 12 + enc->extradata_size);
00167         avio_write(pb, "\0\0\0\14frmaalac", 12);
00168         avio_write(pb, enc->extradata, enc->extradata_size);
00169     } else if (enc->codec_id == AV_CODEC_ID_AMR_NB) {
00170         ffio_wfourcc(pb, "kuki");
00171         avio_wb64(pb, 29);
00172         avio_write(pb, "\0\0\0\14frmasamr", 12);
00173         avio_wb32(pb, 0x11); /* size */
00174         avio_write(pb, "samrFFMP", 8);
00175         avio_w8(pb, 0); /* decoder version */
00176 
00177         avio_wb16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */
00178         avio_w8(pb, 0x00); /* Mode change period (no restriction) */
00179         avio_w8(pb, 0x01); /* Frames per sample */
00180     } else if (enc->codec_id == AV_CODEC_ID_QDM2) {
00181         ffio_wfourcc(pb, "kuki");
00182         avio_wb64(pb, enc->extradata_size);
00183         avio_write(pb, enc->extradata, enc->extradata_size);
00184     }
00185 
00186     if (av_dict_count(s->metadata)) {
00187         ffio_wfourcc(pb, "info"); //< Information chunk
00188         while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX))) {
00189             chunk_size += strlen(t->key) + strlen(t->value) + 2;
00190         }
00191         avio_wb64(pb, chunk_size + 4);
00192         avio_wb32(pb, av_dict_count(s->metadata));
00193         t = NULL;
00194         while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX))) {
00195             avio_put_str(pb, t->key);
00196             avio_put_str(pb, t->value);
00197         }
00198     }
00199 
00200     ffio_wfourcc(pb, "data"); //< Audio Data chunk
00201     caf->data = avio_tell(pb);
00202     avio_wb64(pb, -1);        //< mChunkSize
00203     avio_wb32(pb, 0);         //< mEditCount
00204 
00205     avio_flush(pb);
00206     return 0;
00207 }
00208 
00209 static int caf_write_packet(AVFormatContext *s, AVPacket *pkt)
00210 {
00211     CAFContext *caf = s->priv_data;
00212 
00213     avio_write(s->pb, pkt->data, pkt->size);
00214     if (!s->streams[0]->codec->block_align) {
00215         void *pkt_sizes = caf->pkt_sizes;
00216         int i, alloc_size = caf->size_entries_used + 5;
00217         if (alloc_size < 0) {
00218             caf->pkt_sizes = NULL;
00219         } else {
00220             caf->pkt_sizes = av_fast_realloc(caf->pkt_sizes,
00221                                              &caf->size_buffer_size,
00222                                              alloc_size);
00223         }
00224         if (!caf->pkt_sizes) {
00225             av_free(pkt_sizes);
00226             return AVERROR(ENOMEM);
00227         }
00228         for (i = 4; i > 0; i--) {
00229             unsigned top = pkt->size >> i * 7;
00230             if (top)
00231                 caf->pkt_sizes[caf->size_entries_used++] = 128 | top;
00232         }
00233         caf->pkt_sizes[caf->size_entries_used++] = pkt->size & 127;
00234         caf->packets++;
00235     }
00236     return 0;
00237 }
00238 
00239 static int caf_write_trailer(AVFormatContext *s)
00240 {
00241     AVIOContext *pb = s->pb;
00242     AVCodecContext *enc = s->streams[0]->codec;
00243 
00244     if (pb->seekable) {
00245         CAFContext *caf = s->priv_data;
00246         int64_t file_size = avio_tell(pb);
00247 
00248         avio_seek(pb, caf->data, SEEK_SET);
00249         avio_wb64(pb, file_size - caf->data - 8);
00250         avio_seek(pb, file_size, SEEK_SET);
00251         if (!enc->block_align) {
00252             ffio_wfourcc(pb, "pakt");
00253             avio_wb64(pb, caf->size_entries_used + 24);
00254             avio_wb64(pb, caf->packets); 
00255             avio_wb64(pb, caf->packets * samples_per_packet(enc->codec_id, enc->channels)); 
00256             avio_wb32(pb, 0); 
00257             avio_wb32(pb, 0); 
00258             avio_write(pb, caf->pkt_sizes, caf->size_entries_used);
00259             av_freep(&caf->pkt_sizes);
00260             caf->size_buffer_size = 0;
00261         }
00262         avio_flush(pb);
00263     }
00264     return 0;
00265 }
00266 
00267 AVOutputFormat ff_caf_muxer = {
00268     .name           = "caf",
00269     .long_name      = NULL_IF_CONFIG_SMALL("Apple CAF (Core Audio Format)"),
00270     .mime_type      = "audio/x-caf",
00271     .extensions     = "caf",
00272     .priv_data_size = sizeof(CAFContext),
00273     .audio_codec    = AV_CODEC_ID_PCM_S16BE,
00274     .video_codec    = AV_CODEC_ID_NONE,
00275     .write_header   = caf_write_header,
00276     .write_packet   = caf_write_packet,
00277     .write_trailer  = caf_write_trailer,
00278     .codec_tag      = (const AVCodecTag* const []){ff_codec_caf_tags, 0},
00279 };