FFmpeg
latmenc.c
Go to the documentation of this file.
1 /*
2  * LATM/LOAS muxer
3  * Copyright (c) 2011 Kieran Kunhya <kieran@kunhya.com>
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 "libavcodec/get_bits.h"
23 #include "libavcodec/put_bits.h"
24 #include "libavcodec/codec_id.h"
25 #include "libavcodec/codec_par.h"
26 #include "libavcodec/packet.h"
27 #include "libavcodec/mpeg4audio.h"
29 #include "libavutil/opt.h"
30 #include "avformat.h"
31 #include "internal.h"
32 #include "mux.h"
33 #include "rawenc.h"
34 
35 #define MAX_EXTRADATA_SIZE 1024
36 
37 typedef struct LATMContext {
39  int off;
42  int counter;
43  int mod;
44  uint8_t buffer[0x1fff + MAX_EXTRADATA_SIZE + 1024];
45 } LATMContext;
46 
47 static const AVOption options[] = {
48  {"smc-interval", "StreamMuxConfig interval.",
49  offsetof(LATMContext, mod), AV_OPT_TYPE_INT, {.i64 = 0x0014}, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
50  {NULL},
51 };
52 
53 static const AVClass latm_muxer_class = {
54  .class_name = "LATM/LOAS muxer",
55  .item_name = av_default_item_name,
56  .option = options,
57  .version = LIBAVUTIL_VERSION_INT,
58 };
59 
60 static int latm_decode_extradata(AVFormatContext *s, uint8_t *buf, int size)
61 {
62  LATMContext *ctx = s->priv_data;
63  MPEG4AudioConfig m4ac;
64 
65  if (size > MAX_EXTRADATA_SIZE) {
66  av_log(s, AV_LOG_ERROR, "Extradata is larger than currently supported.\n");
67  return AVERROR_INVALIDDATA;
68  }
69  ctx->off = avpriv_mpeg4audio_get_config2(&m4ac, buf, size, 1, s);
70  if (ctx->off < 0)
71  return ctx->off;
72 
73  if (ctx->object_type == AOT_ALS && (ctx->off & 7)) {
74  // as long as avpriv_mpeg4audio_get_config works correctly this is impossible
75  av_log(s, AV_LOG_ERROR, "BUG: ALS offset is not byte-aligned\n");
76  return AVERROR_INVALIDDATA;
77  }
78  /* FIXME: are any formats not allowed in LATM? */
79 
80  if (m4ac.object_type > AOT_SBR && m4ac.object_type != AOT_ALS) {
81  av_log(s, AV_LOG_ERROR, "Muxing MPEG-4 AOT %d in LATM is not supported\n", m4ac.object_type);
82  return AVERROR_INVALIDDATA;
83  }
84  ctx->channel_conf = m4ac.chan_config;
85  ctx->object_type = m4ac.object_type;
86 
87  return 0;
88 }
89 
91 {
92  AVCodecParameters *par = s->streams[0]->codecpar;
93 
94  if (par->codec_id == AV_CODEC_ID_AAC_LATM)
95  return 0;
96  if (par->codec_id != AV_CODEC_ID_AAC && par->codec_id != AV_CODEC_ID_MP4ALS) {
97  av_log(s, AV_LOG_ERROR, "Only AAC, LATM and ALS are supported\n");
98  return AVERROR(EINVAL);
99  }
100 
101  if (par->extradata_size > 0 &&
103  return AVERROR_INVALIDDATA;
104 
105  return 0;
106 }
107 
108 static void copy_bits(PutBitContext *pb, const uint8_t *src, int length)
109 {
110  int words = length >> 4;
111  int bits = length & 15;
112  int i;
113  for (i = 0; i < words; i++)
114  put_bits(pb, 16, AV_RB16(src + 2 * i));
115  if (bits)
116  put_bits(pb, bits, AV_RB16(src + 2 * words) >> (16 - bits));
117 }
118 
120 {
121  LATMContext *ctx = s->priv_data;
122  AVCodecParameters *par = s->streams[0]->codecpar;
123  int header_size;
124 
125  /* AudioMuxElement */
126  put_bits(bs, 1, !!ctx->counter);
127 
128  if (!ctx->counter) {
129  /* StreamMuxConfig */
130  put_bits(bs, 1, 0); /* audioMuxVersion */
131  put_bits(bs, 1, 1); /* allStreamsSameTimeFraming */
132  put_bits(bs, 6, 0); /* numSubFrames */
133  put_bits(bs, 4, 0); /* numProgram */
134  put_bits(bs, 3, 0); /* numLayer */
135 
136  /* AudioSpecificConfig */
137  if (ctx->object_type == AOT_ALS) {
138  header_size = (par->extradata_size - (ctx->off >> 3)) * 8;
139  copy_bits(bs, &par->extradata[ctx->off >> 3], header_size);
140  } else {
141  // + 3 assumes not scalable and dependsOnCoreCoder == 0,
142  // see decode_ga_specific_config in libavcodec/aacdec.c
143  copy_bits(bs, par->extradata, ctx->off + 3);
144 
145  if (!ctx->channel_conf) {
146  GetBitContext gb;
147  int ret = init_get_bits8(&gb, par->extradata, par->extradata_size);
148  av_assert0(ret >= 0); // extradata size has been checked already, so this should not fail
149  skip_bits_long(&gb, ctx->off + 3);
150  ff_copy_pce_data(bs, &gb);
151  }
152  }
153 
154  put_bits(bs, 3, 0); /* frameLengthType */
155  put_bits(bs, 8, 0xff); /* latmBufferFullness */
156 
157  put_bits(bs, 1, 0); /* otherDataPresent */
158  put_bits(bs, 1, 0); /* crcCheckPresent */
159  }
160 
161  ctx->counter++;
162  ctx->counter %= ctx->mod;
163 }
164 
166 {
167  LATMContext *ctx = s->priv_data;
168  AVCodecParameters *par = s->streams[0]->codecpar;
169  AVIOContext *pb = s->pb;
170  PutBitContext bs;
171  int i, len;
172  uint8_t loas_header[] = "\x56\xe0\x00";
173 
174  if (par->codec_id == AV_CODEC_ID_AAC_LATM)
175  return ff_raw_write_packet(s, pkt);
176 
177  if (!par->extradata) {
178  if(pkt->size > 2 && pkt->data[0] == 0x56 && (pkt->data[1] >> 4) == 0xe &&
179  (AV_RB16(pkt->data + 1) & 0x1FFF) + 3 == pkt->size)
180  return ff_raw_write_packet(s, pkt);
181  else {
182  uint8_t *side_data;
183  size_t side_data_size;
184  int ret;
185 
187  &side_data_size);
188  if (side_data_size) {
189  if (latm_decode_extradata(s, side_data, side_data_size) < 0)
190  return AVERROR_INVALIDDATA;
191  ret = ff_alloc_extradata(par, side_data_size);
192  if (ret < 0)
193  return ret;
194  memcpy(par->extradata, side_data, side_data_size);
195  } else
196  return AVERROR_INVALIDDATA;
197  }
198  }
199 
200  if (pkt->size > 0x1fff)
201  goto too_large;
202 
203  init_put_bits(&bs, ctx->buffer, pkt->size+1024+MAX_EXTRADATA_SIZE);
204 
206 
207  /* PayloadLengthInfo() */
208  for (i = 0; i <= pkt->size-255; i+=255)
209  put_bits(&bs, 8, 255);
210 
211  put_bits(&bs, 8, pkt->size-i);
212 
213  /* The LATM payload is written unaligned */
214 
215  /* PayloadMux() */
216  if (pkt->size && (pkt->data[0] & 0xe1) == 0x81) {
217  // Convert byte-aligned DSE to non-aligned.
218  // Due to the input format encoding we know that
219  // it is naturally byte-aligned in the input stream,
220  // so there are no padding bits to account for.
221  // To avoid having to add padding bits and rearrange
222  // the whole stream we just remove the byte-align flag.
223  // This allows us to remux our FATE AAC samples into latm
224  // files that are still playable with minimal effort.
225  put_bits(&bs, 8, pkt->data[0] & 0xfe);
226  copy_bits(&bs, pkt->data + 1, 8*pkt->size - 8);
227  } else
228  copy_bits(&bs, pkt->data, 8*pkt->size);
229 
230  flush_put_bits(&bs);
231 
232  len = put_bytes_output(&bs);
233 
234  if (len > 0x1fff)
235  goto too_large;
236 
237  loas_header[1] |= (len >> 8) & 0x1f;
238  loas_header[2] |= len & 0xff;
239 
240  avio_write(pb, loas_header, 3);
241  avio_write(pb, ctx->buffer, len);
242 
243  return 0;
244 
245 too_large:
246  av_log(s, AV_LOG_ERROR, "LATM packet size larger than maximum size 0x1fff\n");
247  return AVERROR_INVALIDDATA;
248 }
249 
251  const AVPacket *pkt)
252 {
253  int ret = 1;
254 
255  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
256  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
257  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
258  }
259 
260  return ret;
261 }
262 
264  .name = "latm",
265  .long_name = NULL_IF_CONFIG_SMALL("LOAS/LATM"),
266  .mime_type = "audio/MP4A-LATM",
267  .extensions = "latm,loas",
268  .priv_data_size = sizeof(LATMContext),
269  .audio_codec = AV_CODEC_ID_AAC,
270  .video_codec = AV_CODEC_ID_NONE,
273  .priv_class = &latm_muxer_class,
276 };
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:76
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVERROR
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
opt.h
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:54
latm_muxer_class
static const AVClass latm_muxer_class
Definition: latmenc.c:53
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:481
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
check_bitstream
static int check_bitstream(AVFormatContext *s, FFStream *sti, AVPacket *pkt)
Definition: mux.c:1073
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
MPEG4AudioConfig
Definition: mpeg4audio.h:29
LATMContext::av_class
AVClass * av_class
Definition: latmenc.c:38
mpeg4audio.h
latm_check_bitstream
static int latm_check_bitstream(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: latmenc.c:250
GetBitContext
Definition: get_bits.h:61
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
codec_id.h
avpriv_mpeg4audio_get_config2
int avpriv_mpeg4audio_get_config2(MPEG4AudioConfig *c, const uint8_t *buf, int size, int sync_extension, void *logctx)
Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration.
Definition: mpeg4audio.c:165
s
#define s(width, name)
Definition: cbs_vp9.c:256
LATMContext::off
int off
Definition: latmenc.c:39
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:281
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_copy_pce_data
static int ff_copy_pce_data(PutBitContext *pb, GetBitContext *gb)
Definition: mpeg4audio_copy_pce.h:38
ff_raw_write_packet
int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rawenc.c:31
get_bits.h
LATMContext::object_type
int object_type
Definition: latmenc.c:41
PutBitContext
Definition: put_bits.h:50
AVFormatContext
Format I/O context.
Definition: avformat.h:1216
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_CODEC_ID_MP4ALS
@ AV_CODEC_ID_MP4ALS
Definition: codec_id.h:480
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:80
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:437
latm_decode_extradata
static int latm_decode_extradata(AVFormatContext *s, uint8_t *buf, int size)
Definition: latmenc.c:60
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:115
latm_write_packet
static int latm_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: latmenc.c:165
size
int size
Definition: twinvq_data.h:10344
LATMContext::buffer
uint8_t buffer[0x1fff+MAX_EXTRADATA_SIZE+1024]
Definition: latmenc.c:44
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:232
LATMContext::counter
int counter
Definition: latmenc.c:42
latm_write_header
static int latm_write_header(AVFormatContext *s)
Definition: latmenc.c:90
ff_latm_muxer
const AVOutputFormat ff_latm_muxer
Definition: latmenc.c:263
rawenc.h
LATMContext
Definition: aacdec.c:264
LATMContext::mod
int mod
Definition: latmenc.c:43
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
packet.h
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:251
MAX_EXTRADATA_SIZE
#define MAX_EXTRADATA_SIZE
Definition: latmenc.c:35
LATMContext::channel_conf
int channel_conf
Definition: latmenc.c:40
MPEG4AudioConfig::chan_config
int chan_config
Definition: mpeg4audio.h:33
len
int len
Definition: vorbis_enc_data.h:426
mod
static int mod(int a, int b)
Modulo operation with only positive remainders.
Definition: vf_v360.c:750
write_packet
static int write_packet(Muxer *mux, OutputStream *ost, AVPacket *pkt)
Definition: ffmpeg_mux.c:61
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
copy_bits
static void copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Definition: latmenc.c:108
AVClass::class_name
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:71
avformat.h
MPEG4AudioConfig::object_type
int object_type
Definition: mpeg4audio.h:30
ff_stream_add_bitstream_filter
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: mux.c:1311
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AOT_SBR
@ AOT_SBR
Y Spectral Band Replication.
Definition: mpeg4audio.h:77
latm_write_frame_header
static void latm_write_frame_header(AVFormatContext *s, PutBitContext *bs)
Definition: latmenc.c:119
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
AOT_ALS
@ AOT_ALS
Y Audio LosslesS.
Definition: mpeg4audio.h:105
codec_par.h
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:62
AVPacket
This structure stores compressed data.
Definition: packet.h:351
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:484
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
put_bits.h
options
static const AVOption options[]
Definition: latmenc.c:47
mpeg4audio_copy_pce.h
AV_RB16
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_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:238
mux.h