FFmpeg
astenc.c
Go to the documentation of this file.
1 /*
2  * AST muxer
3  * Copyright (c) 2012 James Almer
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 "avformat.h"
23 #include "avio_internal.h"
24 #include "internal.h"
25 #include "ast.h"
26 #include "libavutil/mathematics.h"
27 #include "libavutil/opt.h"
28 
29 typedef struct ASTMuxContext {
30  AVClass *class;
31  int64_t size;
32  int64_t samples;
33  int64_t loopstart;
34  int64_t loopend;
35  int fbs;
37 
38 #define CHECK_LOOP(type) \
39  if (ast->loop ## type > 0) { \
40  ast->loop ## type = av_rescale_rnd(ast->loop ## type, par->sample_rate, 1000, AV_ROUND_DOWN); \
41  if (ast->loop ## type < 0 || ast->loop ## type > UINT_MAX) { \
42  av_log(s, AV_LOG_ERROR, "Invalid loop" #type " value\n"); \
43  return AVERROR(EINVAL); \
44  } \
45  }
46 
48 {
49  ASTMuxContext *ast = s->priv_data;
50  AVIOContext *pb = s->pb;
51  AVCodecParameters *par;
52  unsigned int codec_tag;
53 
54  if (s->nb_streams == 1) {
55  par = s->streams[0]->codecpar;
56  } else {
57  av_log(s, AV_LOG_ERROR, "only one stream is supported\n");
58  return AVERROR(EINVAL);
59  }
60 
61  if (par->codec_id == AV_CODEC_ID_ADPCM_AFC) {
62  av_log(s, AV_LOG_ERROR, "muxing ADPCM AFC is not implemented\n");
63  return AVERROR_PATCHWELCOME;
64  }
65 
66  codec_tag = ff_codec_get_tag(ff_codec_ast_tags, par->codec_id);
67  if (!codec_tag) {
68  av_log(s, AV_LOG_ERROR, "unsupported codec\n");
69  return AVERROR(EINVAL);
70  }
71 
72  if (ast->loopend > 0 && ast->loopstart >= ast->loopend) {
73  av_log(s, AV_LOG_ERROR, "loopend can't be less or equal to loopstart\n");
74  return AVERROR(EINVAL);
75  }
76 
77  /* Convert milliseconds to samples */
78  CHECK_LOOP(start)
79  CHECK_LOOP(end)
80 
81  ffio_wfourcc(pb, "STRM");
82 
83  ast->size = avio_tell(pb);
84  avio_wb32(pb, 0); /* File size minus header */
85  avio_wb16(pb, codec_tag);
86  avio_wb16(pb, 16); /* Bit depth */
87  avio_wb16(pb, par->channels);
88  avio_wb16(pb, 0); /* Loop flag */
89  avio_wb32(pb, par->sample_rate);
90 
91  ast->samples = avio_tell(pb);
92  avio_wb32(pb, 0); /* Number of samples */
93  avio_wb32(pb, 0); /* Loopstart */
94  avio_wb32(pb, 0); /* Loopend */
95  avio_wb32(pb, 0); /* Size of first block */
96 
97  /* Unknown */
98  avio_wb32(pb, 0);
99  avio_wl32(pb, 0x7F);
100  avio_wb64(pb, 0);
101  avio_wb64(pb, 0);
102  avio_wb32(pb, 0);
103 
104  return 0;
105 }
106 
108 {
109  AVIOContext *pb = s->pb;
110  ASTMuxContext *ast = s->priv_data;
111  AVCodecParameters *par = s->streams[0]->codecpar;
112  int size = pkt->size / par->channels;
113 
114  if (s->streams[0]->nb_frames == 0)
115  ast->fbs = size;
116 
117  ffio_wfourcc(pb, "BLCK");
118  avio_wb32(pb, size); /* Block size */
119 
120  /* padding */
121  ffio_fill(pb, 0, 24);
122 
123  avio_write(pb, pkt->data, pkt->size);
124 
125  return 0;
126 }
127 
129 {
130  AVIOContext *pb = s->pb;
131  ASTMuxContext *ast = s->priv_data;
132  AVCodecParameters *par = s->streams[0]->codecpar;
133  int64_t file_size = avio_tell(pb);
134  int64_t samples = (file_size - 64 - (32 * s->streams[0]->nb_frames)) / par->block_align; /* PCM_S16BE_PLANAR */
135 
136  av_log(s, AV_LOG_DEBUG, "total samples: %"PRId64"\n", samples);
137 
138  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
139  /* Number of samples */
140  avio_seek(pb, ast->samples, SEEK_SET);
141  avio_wb32(pb, samples);
142 
143  /* Loopstart if provided */
144  if (ast->loopstart > 0) {
145  if (ast->loopstart >= samples) {
146  av_log(s, AV_LOG_WARNING, "Loopstart value is out of range and will be ignored\n");
147  ast->loopstart = -1;
148  avio_skip(pb, 4);
149  } else
150  avio_wb32(pb, ast->loopstart);
151  } else
152  avio_skip(pb, 4);
153 
154  /* Loopend if provided. Otherwise number of samples again */
155  if (ast->loopend && ast->loopstart >= 0) {
156  if (ast->loopend > samples) {
157  av_log(s, AV_LOG_WARNING, "Loopend value is out of range and will be ignored\n");
158  ast->loopend = samples;
159  }
160  avio_wb32(pb, ast->loopend);
161  } else {
162  avio_wb32(pb, samples);
163  }
164 
165  /* Size of first block */
166  avio_wb32(pb, ast->fbs);
167 
168  /* File size minus header */
169  avio_seek(pb, ast->size, SEEK_SET);
170  avio_wb32(pb, file_size - 64);
171 
172  /* Loop flag */
173  if (ast->loopstart >= 0) {
174  avio_skip(pb, 6);
175  avio_wb16(pb, 0xFFFF);
176  }
177 
178  avio_seek(pb, file_size, SEEK_SET);
179  }
180  return 0;
181 }
182 
183 #define OFFSET(obj) offsetof(ASTMuxContext, obj)
184 static const AVOption options[] = {
185  { "loopstart", "Loopstart position in milliseconds.", OFFSET(loopstart), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
186  { "loopend", "Loopend position in milliseconds.", OFFSET(loopend), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
187  { NULL },
188 };
189 
190 static const AVClass ast_muxer_class = {
191  .class_name = "AST muxer",
192  .item_name = av_default_item_name,
193  .option = options,
194  .version = LIBAVUTIL_VERSION_INT,
195 };
196 
198  .name = "ast",
199  .long_name = NULL_IF_CONFIG_SMALL("AST (Audio Stream)"),
200  .extensions = "ast",
201  .priv_data_size = sizeof(ASTMuxContext),
202  .audio_codec = AV_CODEC_ID_PCM_S16BE_PLANAR,
203  .video_codec = AV_CODEC_ID_NONE,
207  .priv_class = &ast_muxer_class,
208  .codec_tag = ff_ast_codec_tags_list,
209 };
OFFSET
#define OFFSET(obj)
Definition: astenc.c:183
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVOutputFormat::name
const char * name
Definition: avformat.h:496
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
ffio_wfourcc
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:105
ASTMuxContext::fbs
int fbs
Definition: astenc.c:35
ast_write_trailer
static int ast_write_trailer(AVFormatContext *s)
Definition: astenc.c:128
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ASTMuxContext::size
int64_t size
Definition: astenc.c:31
AVPacket::data
uint8_t * data
Definition: packet.h:373
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:343
AVOption
AVOption.
Definition: opt.h:247
ff_ast_muxer
const AVOutputFormat ff_ast_muxer
Definition: astenc.c:197
mathematics.h
ast.h
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:486
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
ast_muxer_class
static const AVClass ast_muxer_class
Definition: astenc.c:190
s
#define s(width, name)
Definition: cbs_vp9.c:257
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:277
AV_CODEC_ID_ADPCM_AFC
@ AV_CODEC_ID_ADPCM_AFC
Definition: codec_id.h:383
ff_codec_ast_tags
const AVCodecTag ff_codec_ast_tags[]
Definition: ast.c:26
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:225
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ASTMuxContext::loopstart
int64_t loopstart
Definition: astenc.c:33
options
static const AVOption options[]
Definition: astenc.c:184
AVFormatContext
Format I/O context.
Definition: avformat.h:1097
internal.h
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
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
ASTMuxContext::samples
int64_t samples
Definition: astenc.c:32
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:204
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
ASTMuxContext::loopend
int64_t loopend
Definition: astenc.c:34
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVPacket::size
int size
Definition: packet.h:374
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:117
size
int size
Definition: twinvq_data.h:10344
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:379
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:371
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:731
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVOutputFormat
Definition: avformat.h:495
avio_internal.h
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
ff_ast_codec_tags_list
const AVCodecTag *const ff_ast_codec_tags_list[]
Definition: ast.c:32
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
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
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:347
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:333
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:445
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:457
ast_write_header
static int ast_write_header(AVFormatContext *s)
Definition: astenc.c:47
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:347
ast_write_packet
static int ast_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: astenc.c:107
CHECK_LOOP
#define CHECK_LOOP(type)
Definition: astenc.c:38
ASTMuxContext
Definition: astenc.c:29