FFmpeg  3.4.9
rawenc.c
Go to the documentation of this file.
1 /*
2  * RAW muxers
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2005 Alex Beregszaszi
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "libavutil/intreadwrite.h"
24 
25 #include "avformat.h"
26 #include "rawenc.h"
27 #include "internal.h"
28 
30 {
31  avio_write(s->pb, pkt->data, pkt->size);
32  return 0;
33 }
34 
36 {
37  if (s->nb_streams != 1) {
38  av_log(s, AV_LOG_ERROR, "%s files have exactly one stream\n",
39  s->oformat->name);
40  return AVERROR(EINVAL);
41  }
44  av_log(s, AV_LOG_ERROR, "%s files have exactly one audio stream\n",
45  s->oformat->name);
46  return AVERROR(EINVAL);
47  }
50  av_log(s, AV_LOG_ERROR, "%s files have exactly one video stream\n",
51  s->oformat->name);
52  return AVERROR(EINVAL);
53  }
54  return 0;
55 }
56 
57 /* Note: Do not forget to add new entries to the Makefile as well. */
58 
59 #if CONFIG_AC3_MUXER
60 AVOutputFormat ff_ac3_muxer = {
61  .name = "ac3",
62  .long_name = NULL_IF_CONFIG_SMALL("raw AC-3"),
63  .mime_type = "audio/x-ac3",
64  .extensions = "ac3",
65  .audio_codec = AV_CODEC_ID_AC3,
66  .video_codec = AV_CODEC_ID_NONE,
67  .write_header = force_one_stream,
68  .write_packet = ff_raw_write_packet,
69  .flags = AVFMT_NOTIMESTAMPS,
70 };
71 #endif
72 
73 #if CONFIG_ADX_MUXER
74 
75 static int adx_write_trailer(AVFormatContext *s)
76 {
77  AVIOContext *pb = s->pb;
78  AVCodecParameters *par = s->streams[0]->codecpar;
79 
80  if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
81  int64_t file_size = avio_tell(pb);
82  uint64_t sample_count = (file_size - 36) / par->channels / 18 * 32;
83  if (sample_count <= UINT32_MAX) {
84  avio_seek(pb, 12, SEEK_SET);
85  avio_wb32(pb, sample_count);
86  avio_seek(pb, file_size, SEEK_SET);
87  }
88  }
89 
90  return 0;
91 }
92 
93 AVOutputFormat ff_adx_muxer = {
94  .name = "adx",
95  .long_name = NULL_IF_CONFIG_SMALL("CRI ADX"),
96  .extensions = "adx",
97  .audio_codec = AV_CODEC_ID_ADPCM_ADX,
98  .video_codec = AV_CODEC_ID_NONE,
99  .write_header = force_one_stream,
100  .write_packet = ff_raw_write_packet,
101  .write_trailer = adx_write_trailer,
102  .flags = AVFMT_NOTIMESTAMPS,
103 };
104 #endif
105 
106 #if CONFIG_CAVSVIDEO_MUXER
107 AVOutputFormat ff_cavsvideo_muxer = {
108  .name = "cavsvideo",
109  .long_name = NULL_IF_CONFIG_SMALL("raw Chinese AVS (Audio Video Standard) video"),
110  .extensions = "cavs",
111  .audio_codec = AV_CODEC_ID_NONE,
112  .video_codec = AV_CODEC_ID_CAVS,
113  .write_header = force_one_stream,
114  .write_packet = ff_raw_write_packet,
115  .flags = AVFMT_NOTIMESTAMPS,
116 };
117 #endif
118 
119 #if CONFIG_DATA_MUXER
120 AVOutputFormat ff_data_muxer = {
121  .name = "data",
122  .long_name = NULL_IF_CONFIG_SMALL("raw data"),
123  .write_header = force_one_stream,
124  .write_packet = ff_raw_write_packet,
125  .flags = AVFMT_NOTIMESTAMPS,
126 };
127 #endif
128 
129 #if CONFIG_DIRAC_MUXER
130 AVOutputFormat ff_dirac_muxer = {
131  .name = "dirac",
132  .long_name = NULL_IF_CONFIG_SMALL("raw Dirac"),
133  .extensions = "drc,vc2",
134  .audio_codec = AV_CODEC_ID_NONE,
135  .video_codec = AV_CODEC_ID_DIRAC,
136  .write_header = force_one_stream,
137  .write_packet = ff_raw_write_packet,
138  .flags = AVFMT_NOTIMESTAMPS,
139 };
140 #endif
141 
142 #if CONFIG_DNXHD_MUXER
143 AVOutputFormat ff_dnxhd_muxer = {
144  .name = "dnxhd",
145  .long_name = NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
146  .extensions = "dnxhd,dnxhr",
147  .audio_codec = AV_CODEC_ID_NONE,
148  .video_codec = AV_CODEC_ID_DNXHD,
149  .write_header = force_one_stream,
150  .write_packet = ff_raw_write_packet,
151  .flags = AVFMT_NOTIMESTAMPS,
152 };
153 #endif
154 
155 #if CONFIG_DTS_MUXER
156 AVOutputFormat ff_dts_muxer = {
157  .name = "dts",
158  .long_name = NULL_IF_CONFIG_SMALL("raw DTS"),
159  .mime_type = "audio/x-dca",
160  .extensions = "dts",
161  .audio_codec = AV_CODEC_ID_DTS,
162  .video_codec = AV_CODEC_ID_NONE,
163  .write_header = force_one_stream,
164  .write_packet = ff_raw_write_packet,
165  .flags = AVFMT_NOTIMESTAMPS,
166 };
167 #endif
168 
169 #if CONFIG_EAC3_MUXER
170 AVOutputFormat ff_eac3_muxer = {
171  .name = "eac3",
172  .long_name = NULL_IF_CONFIG_SMALL("raw E-AC-3"),
173  .mime_type = "audio/x-eac3",
174  .extensions = "eac3",
175  .audio_codec = AV_CODEC_ID_EAC3,
176  .video_codec = AV_CODEC_ID_NONE,
177  .write_header = force_one_stream,
178  .write_packet = ff_raw_write_packet,
179  .flags = AVFMT_NOTIMESTAMPS,
180 };
181 #endif
182 
183 #if CONFIG_G722_MUXER
184 AVOutputFormat ff_g722_muxer = {
185  .name = "g722",
186  .long_name = NULL_IF_CONFIG_SMALL("raw G.722"),
187  .mime_type = "audio/G722",
188  .extensions = "g722",
189  .audio_codec = AV_CODEC_ID_ADPCM_G722,
190  .video_codec = AV_CODEC_ID_NONE,
191  .write_header = force_one_stream,
192  .write_packet = ff_raw_write_packet,
193  .flags = AVFMT_NOTIMESTAMPS,
194 };
195 #endif
196 
197 #if CONFIG_G723_1_MUXER
198 AVOutputFormat ff_g723_1_muxer = {
199  .name = "g723_1",
200  .long_name = NULL_IF_CONFIG_SMALL("raw G.723.1"),
201  .mime_type = "audio/g723",
202  .extensions = "tco,rco",
203  .audio_codec = AV_CODEC_ID_G723_1,
204  .video_codec = AV_CODEC_ID_NONE,
205  .write_header = force_one_stream,
206  .write_packet = ff_raw_write_packet,
207  .flags = AVFMT_NOTIMESTAMPS,
208 };
209 #endif
210 
211 #if CONFIG_G726_MUXER
212 AVOutputFormat ff_g726_muxer = {
213  .name = "g726",
214  .long_name = NULL_IF_CONFIG_SMALL("raw big-endian G.726 (\"left-justified\")"),
215  .audio_codec = AV_CODEC_ID_ADPCM_G726,
216  .video_codec = AV_CODEC_ID_NONE,
217  .write_header = force_one_stream,
218  .write_packet = ff_raw_write_packet,
219  .flags = AVFMT_NOTIMESTAMPS,
220 };
221 #endif
222 
223 #if CONFIG_G726LE_MUXER
224 AVOutputFormat ff_g726le_muxer = {
225  .name = "g726le",
226  .long_name = NULL_IF_CONFIG_SMALL("raw little-endian G.726 (\"right-justified\")"),
227  .audio_codec = AV_CODEC_ID_ADPCM_G726LE,
228  .video_codec = AV_CODEC_ID_NONE,
229  .write_header = force_one_stream,
230  .write_packet = ff_raw_write_packet,
231  .flags = AVFMT_NOTIMESTAMPS,
232 };
233 #endif
234 
235 #if CONFIG_GSM_MUXER
236 AVOutputFormat ff_gsm_muxer = {
237  .name = "gsm",
238  .long_name = NULL_IF_CONFIG_SMALL("raw GSM"),
239  .mime_type = "audio/x-gsm",
240  .extensions = "gsm",
241  .audio_codec = AV_CODEC_ID_GSM,
242  .video_codec = AV_CODEC_ID_NONE,
243  .write_header = force_one_stream,
244  .write_packet = ff_raw_write_packet,
245  .flags = AVFMT_NOTIMESTAMPS,
246 };
247 #endif
248 
249 #if CONFIG_H261_MUXER
250 AVOutputFormat ff_h261_muxer = {
251  .name = "h261",
252  .long_name = NULL_IF_CONFIG_SMALL("raw H.261"),
253  .mime_type = "video/x-h261",
254  .extensions = "h261",
255  .audio_codec = AV_CODEC_ID_NONE,
256  .video_codec = AV_CODEC_ID_H261,
257  .write_header = force_one_stream,
258  .write_packet = ff_raw_write_packet,
259  .flags = AVFMT_NOTIMESTAMPS,
260 };
261 #endif
262 
263 #if CONFIG_H263_MUXER
264 AVOutputFormat ff_h263_muxer = {
265  .name = "h263",
266  .long_name = NULL_IF_CONFIG_SMALL("raw H.263"),
267  .mime_type = "video/x-h263",
268  .extensions = "h263",
269  .audio_codec = AV_CODEC_ID_NONE,
270  .video_codec = AV_CODEC_ID_H263,
271  .write_header = force_one_stream,
272  .write_packet = ff_raw_write_packet,
273  .flags = AVFMT_NOTIMESTAMPS,
274 };
275 #endif
276 
277 #if CONFIG_H264_MUXER
278 static int h264_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
279 {
280  AVStream *st = s->streams[0];
281  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
282  AV_RB24(pkt->data) != 0x000001)
283  return ff_stream_add_bitstream_filter(st, "h264_mp4toannexb", NULL);
284  return 1;
285 }
286 
287 AVOutputFormat ff_h264_muxer = {
288  .name = "h264",
289  .long_name = NULL_IF_CONFIG_SMALL("raw H.264 video"),
290  .extensions = "h264,264",
291  .audio_codec = AV_CODEC_ID_NONE,
292  .video_codec = AV_CODEC_ID_H264,
293  .write_header = force_one_stream,
294  .write_packet = ff_raw_write_packet,
295  .check_bitstream = h264_check_bitstream,
296  .flags = AVFMT_NOTIMESTAMPS,
297 };
298 #endif
299 
300 #if CONFIG_HEVC_MUXER
301 static int hevc_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
302 {
303  AVStream *st = s->streams[0];
304  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
305  AV_RB24(pkt->data) != 0x000001)
306  return ff_stream_add_bitstream_filter(st, "hevc_mp4toannexb", NULL);
307  return 1;
308 }
309 
310 AVOutputFormat ff_hevc_muxer = {
311  .name = "hevc",
312  .long_name = NULL_IF_CONFIG_SMALL("raw HEVC video"),
313  .extensions = "hevc,h265,265",
314  .audio_codec = AV_CODEC_ID_NONE,
315  .video_codec = AV_CODEC_ID_HEVC,
316  .write_header = force_one_stream,
317  .write_packet = ff_raw_write_packet,
318  .check_bitstream = hevc_check_bitstream,
319  .flags = AVFMT_NOTIMESTAMPS,
320 };
321 #endif
322 
323 #if CONFIG_M4V_MUXER
324 AVOutputFormat ff_m4v_muxer = {
325  .name = "m4v",
326  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-4 video"),
327  .extensions = "m4v",
328  .audio_codec = AV_CODEC_ID_NONE,
329  .video_codec = AV_CODEC_ID_MPEG4,
330  .write_header = force_one_stream,
331  .write_packet = ff_raw_write_packet,
332  .flags = AVFMT_NOTIMESTAMPS,
333 };
334 #endif
335 
336 #if CONFIG_MJPEG_MUXER
337 AVOutputFormat ff_mjpeg_muxer = {
338  .name = "mjpeg",
339  .long_name = NULL_IF_CONFIG_SMALL("raw MJPEG video"),
340  .mime_type = "video/x-mjpeg",
341  .extensions = "mjpg,mjpeg",
342  .audio_codec = AV_CODEC_ID_NONE,
343  .video_codec = AV_CODEC_ID_MJPEG,
344  .write_header = force_one_stream,
345  .write_packet = ff_raw_write_packet,
346  .flags = AVFMT_NOTIMESTAMPS,
347 };
348 #endif
349 
350 #if CONFIG_SINGLEJPEG_MUXER
351 AVOutputFormat ff_singlejpeg_muxer = {
352  .name = "singlejpeg",
353  .long_name = NULL_IF_CONFIG_SMALL("JPEG single image"),
354  .mime_type = "image/jpeg",
355  .audio_codec = AV_CODEC_ID_NONE,
356  .video_codec = AV_CODEC_ID_MJPEG,
357  .write_packet = ff_raw_write_packet,
358  .flags = AVFMT_NOTIMESTAMPS,
359  .write_header = force_one_stream,
360 };
361 #endif
362 
363 #if CONFIG_MLP_MUXER
364 AVOutputFormat ff_mlp_muxer = {
365  .name = "mlp",
366  .long_name = NULL_IF_CONFIG_SMALL("raw MLP"),
367  .extensions = "mlp",
368  .audio_codec = AV_CODEC_ID_MLP,
369  .video_codec = AV_CODEC_ID_NONE,
370  .write_header = force_one_stream,
371  .write_packet = ff_raw_write_packet,
372  .flags = AVFMT_NOTIMESTAMPS,
373 };
374 #endif
375 
376 #if CONFIG_MP2_MUXER
377 AVOutputFormat ff_mp2_muxer = {
378  .name = "mp2",
379  .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
380  .mime_type = "audio/mpeg",
381  .extensions = "mp2,m2a,mpa",
382  .audio_codec = AV_CODEC_ID_MP2,
383  .video_codec = AV_CODEC_ID_NONE,
384  .write_packet = ff_raw_write_packet,
385  .flags = AVFMT_NOTIMESTAMPS,
386 };
387 #endif
388 
389 #if CONFIG_MPEG1VIDEO_MUXER
390 AVOutputFormat ff_mpeg1video_muxer = {
391  .name = "mpeg1video",
392  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
393  .mime_type = "video/mpeg",
394  .extensions = "mpg,mpeg,m1v",
395  .audio_codec = AV_CODEC_ID_NONE,
396  .video_codec = AV_CODEC_ID_MPEG1VIDEO,
397  .write_header = force_one_stream,
398  .write_packet = ff_raw_write_packet,
399  .flags = AVFMT_NOTIMESTAMPS,
400 };
401 #endif
402 
403 #if CONFIG_MPEG2VIDEO_MUXER
404 AVOutputFormat ff_mpeg2video_muxer = {
405  .name = "mpeg2video",
406  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
407  .extensions = "m2v",
408  .audio_codec = AV_CODEC_ID_NONE,
409  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
410  .write_header = force_one_stream,
411  .write_packet = ff_raw_write_packet,
412  .flags = AVFMT_NOTIMESTAMPS,
413 };
414 #endif
415 
416 #if CONFIG_RAWVIDEO_MUXER
417 AVOutputFormat ff_rawvideo_muxer = {
418  .name = "rawvideo",
419  .long_name = NULL_IF_CONFIG_SMALL("raw video"),
420  .extensions = "yuv,rgb",
421  .audio_codec = AV_CODEC_ID_NONE,
422  .video_codec = AV_CODEC_ID_RAWVIDEO,
423  .write_packet = ff_raw_write_packet,
424  .flags = AVFMT_NOTIMESTAMPS,
425 };
426 #endif
427 
428 #if CONFIG_TRUEHD_MUXER
429 AVOutputFormat ff_truehd_muxer = {
430  .name = "truehd",
431  .long_name = NULL_IF_CONFIG_SMALL("raw TrueHD"),
432  .extensions = "thd",
433  .audio_codec = AV_CODEC_ID_TRUEHD,
434  .video_codec = AV_CODEC_ID_NONE,
435  .write_header = force_one_stream,
436  .write_packet = ff_raw_write_packet,
437  .flags = AVFMT_NOTIMESTAMPS,
438 };
439 #endif
440 
441 #if CONFIG_VC1_MUXER
442 AVOutputFormat ff_vc1_muxer = {
443  .name = "vc1",
444  .long_name = NULL_IF_CONFIG_SMALL("raw VC-1 video"),
445  .extensions = "vc1",
446  .audio_codec = AV_CODEC_ID_NONE,
447  .video_codec = AV_CODEC_ID_VC1,
448  .write_header = force_one_stream,
449  .write_packet = ff_raw_write_packet,
450  .flags = AVFMT_NOTIMESTAMPS,
451 };
452 #endif
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
Bytestream IO Context.
Definition: avio.h:161
static int force_one_stream(AVFormatContext *s)
Definition: rawenc.c:35
enum AVCodecID video_codec
default video codec
Definition: avformat.h:535
int size
Definition: avcodec.h:1680
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:244
#define AV_RB24
Definition: intreadwrite.h:64
static AVPacket pkt
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4144
Format I/O context.
Definition: avformat.h:1349
#define AV_RB32
Definition: intreadwrite.h:130
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1417
uint8_t * data
Definition: avcodec.h:1679
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:556
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:216
#define av_log(a,...)
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1368
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:181
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4148
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1405
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
const char * name
Definition: avformat.h:524
int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rawenc.c:29
if(ret< 0)
Definition: vf_mcdeint.c:279
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:219
Stream structure.
Definition: avformat.h:889
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:486
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
AVIOContext * pb
I/O context.
Definition: avformat.h:1391
Main libavformat public API header.
as in Berlin toast format
Definition: avcodec.h:574
enum AVCodecID audio_codec
default audio codec
Definition: avformat.h:534
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5343
int channels
Audio only.
Definition: avcodec.h:4258
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:382
AVCodecParameters * codecpar
Definition: avformat.h:1252
This structure stores compressed data.
Definition: avcodec.h:1656