FFmpeg
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 
29 int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
30 {
31  avio_write(s->pb, pkt->data, pkt->size);
32  return 0;
33 }
34 
35 static int force_one_stream(AVFormatContext *s)
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  }
42  if ( s->oformat->audio_codec != AV_CODEC_ID_NONE
43  && s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
44  av_log(s, AV_LOG_ERROR, "%s files have exactly one audio stream\n",
45  s->oformat->name);
46  return AVERROR(EINVAL);
47  }
48  if ( s->oformat->video_codec != AV_CODEC_ID_NONE
49  && s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
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_APTX_MUXER
107 AVOutputFormat ff_aptx_muxer = {
108  .name = "aptx",
109  .long_name = NULL_IF_CONFIG_SMALL("raw aptX (Audio Processing Technology for Bluetooth)"),
110  .extensions = "aptx",
111  .audio_codec = AV_CODEC_ID_APTX,
112  .video_codec = AV_CODEC_ID_NONE,
113  .write_header = force_one_stream,
114  .write_packet = ff_raw_write_packet,
115  .flags = AVFMT_NOTIMESTAMPS,
116 };
117 #endif
118 
119 #if CONFIG_APTX_HD_MUXER
120 AVOutputFormat ff_aptx_hd_muxer = {
121  .name = "aptx_hd",
122  .long_name = NULL_IF_CONFIG_SMALL("raw aptX HD (Audio Processing Technology for Bluetooth)"),
123  .extensions = "aptxhd",
124  .audio_codec = AV_CODEC_ID_APTX_HD,
125  .video_codec = AV_CODEC_ID_NONE,
126  .write_header = force_one_stream,
127  .write_packet = ff_raw_write_packet,
128  .flags = AVFMT_NOTIMESTAMPS,
129 };
130 #endif
131 
132 #if CONFIG_AVS2_MUXER
133 AVOutputFormat ff_avs2_muxer = {
134  .name = "avs2",
135  .long_name = NULL_IF_CONFIG_SMALL("raw AVS2-P2/IEEE1857.4 video"),
136  .extensions = "avs,avs2",
137  .audio_codec = AV_CODEC_ID_NONE,
138  .video_codec = AV_CODEC_ID_AVS2,
139  .write_header = force_one_stream,
140  .write_packet = ff_raw_write_packet,
141  .flags = AVFMT_NOTIMESTAMPS,
142 };
143 #endif
144 
145 #if CONFIG_CAVSVIDEO_MUXER
146 AVOutputFormat ff_cavsvideo_muxer = {
147  .name = "cavsvideo",
148  .long_name = NULL_IF_CONFIG_SMALL("raw Chinese AVS (Audio Video Standard) video"),
149  .extensions = "cavs",
150  .audio_codec = AV_CODEC_ID_NONE,
151  .video_codec = AV_CODEC_ID_CAVS,
152  .write_header = force_one_stream,
153  .write_packet = ff_raw_write_packet,
154  .flags = AVFMT_NOTIMESTAMPS,
155 };
156 #endif
157 
158 #if CONFIG_CODEC2RAW_MUXER
159 AVOutputFormat ff_codec2raw_muxer = {
160  .name = "codec2raw",
161  .long_name = NULL_IF_CONFIG_SMALL("raw codec2 muxer"),
162  .audio_codec = AV_CODEC_ID_CODEC2,
163  .video_codec = AV_CODEC_ID_NONE,
164  .write_header = force_one_stream,
165  .write_packet = ff_raw_write_packet,
166  .flags = AVFMT_NOTIMESTAMPS,
167 };
168 #endif
169 
170 
171 #if CONFIG_DATA_MUXER
172 AVOutputFormat ff_data_muxer = {
173  .name = "data",
174  .long_name = NULL_IF_CONFIG_SMALL("raw data"),
175  .write_header = force_one_stream,
176  .write_packet = ff_raw_write_packet,
177  .flags = AVFMT_NOTIMESTAMPS,
178 };
179 #endif
180 
181 #if CONFIG_DIRAC_MUXER
182 AVOutputFormat ff_dirac_muxer = {
183  .name = "dirac",
184  .long_name = NULL_IF_CONFIG_SMALL("raw Dirac"),
185  .extensions = "drc,vc2",
186  .audio_codec = AV_CODEC_ID_NONE,
187  .video_codec = AV_CODEC_ID_DIRAC,
188  .write_header = force_one_stream,
189  .write_packet = ff_raw_write_packet,
190  .flags = AVFMT_NOTIMESTAMPS,
191 };
192 #endif
193 
194 #if CONFIG_DNXHD_MUXER
195 AVOutputFormat ff_dnxhd_muxer = {
196  .name = "dnxhd",
197  .long_name = NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
198  .extensions = "dnxhd,dnxhr",
199  .audio_codec = AV_CODEC_ID_NONE,
200  .video_codec = AV_CODEC_ID_DNXHD,
201  .write_header = force_one_stream,
202  .write_packet = ff_raw_write_packet,
203  .flags = AVFMT_NOTIMESTAMPS,
204 };
205 #endif
206 
207 #if CONFIG_DTS_MUXER
208 AVOutputFormat ff_dts_muxer = {
209  .name = "dts",
210  .long_name = NULL_IF_CONFIG_SMALL("raw DTS"),
211  .mime_type = "audio/x-dca",
212  .extensions = "dts",
213  .audio_codec = AV_CODEC_ID_DTS,
214  .video_codec = AV_CODEC_ID_NONE,
215  .write_header = force_one_stream,
216  .write_packet = ff_raw_write_packet,
217  .flags = AVFMT_NOTIMESTAMPS,
218 };
219 #endif
220 
221 #if CONFIG_EAC3_MUXER
222 AVOutputFormat ff_eac3_muxer = {
223  .name = "eac3",
224  .long_name = NULL_IF_CONFIG_SMALL("raw E-AC-3"),
225  .mime_type = "audio/x-eac3",
226  .extensions = "eac3",
227  .audio_codec = AV_CODEC_ID_EAC3,
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_G722_MUXER
236 AVOutputFormat ff_g722_muxer = {
237  .name = "g722",
238  .long_name = NULL_IF_CONFIG_SMALL("raw G.722"),
239  .mime_type = "audio/G722",
240  .extensions = "g722",
241  .audio_codec = AV_CODEC_ID_ADPCM_G722,
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_G723_1_MUXER
250 AVOutputFormat ff_g723_1_muxer = {
251  .name = "g723_1",
252  .long_name = NULL_IF_CONFIG_SMALL("raw G.723.1"),
253  .mime_type = "audio/g723",
254  .extensions = "tco,rco",
255  .audio_codec = AV_CODEC_ID_G723_1,
256  .video_codec = AV_CODEC_ID_NONE,
257  .write_header = force_one_stream,
258  .write_packet = ff_raw_write_packet,
259  .flags = AVFMT_NOTIMESTAMPS,
260 };
261 #endif
262 
263 #if CONFIG_G726_MUXER
264 AVOutputFormat ff_g726_muxer = {
265  .name = "g726",
266  .long_name = NULL_IF_CONFIG_SMALL("raw big-endian G.726 (\"left-justified\")"),
267  .audio_codec = AV_CODEC_ID_ADPCM_G726,
268  .video_codec = AV_CODEC_ID_NONE,
269  .write_header = force_one_stream,
270  .write_packet = ff_raw_write_packet,
271  .flags = AVFMT_NOTIMESTAMPS,
272 };
273 #endif
274 
275 #if CONFIG_G726LE_MUXER
276 AVOutputFormat ff_g726le_muxer = {
277  .name = "g726le",
278  .long_name = NULL_IF_CONFIG_SMALL("raw little-endian G.726 (\"right-justified\")"),
279  .audio_codec = AV_CODEC_ID_ADPCM_G726LE,
280  .video_codec = AV_CODEC_ID_NONE,
281  .write_header = force_one_stream,
282  .write_packet = ff_raw_write_packet,
283  .flags = AVFMT_NOTIMESTAMPS,
284 };
285 #endif
286 
287 #if CONFIG_GSM_MUXER
288 AVOutputFormat ff_gsm_muxer = {
289  .name = "gsm",
290  .long_name = NULL_IF_CONFIG_SMALL("raw GSM"),
291  .mime_type = "audio/x-gsm",
292  .extensions = "gsm",
293  .audio_codec = AV_CODEC_ID_GSM,
294  .video_codec = AV_CODEC_ID_NONE,
295  .write_header = force_one_stream,
296  .write_packet = ff_raw_write_packet,
297  .flags = AVFMT_NOTIMESTAMPS,
298 };
299 #endif
300 
301 #if CONFIG_H261_MUXER
302 AVOutputFormat ff_h261_muxer = {
303  .name = "h261",
304  .long_name = NULL_IF_CONFIG_SMALL("raw H.261"),
305  .mime_type = "video/x-h261",
306  .extensions = "h261",
307  .audio_codec = AV_CODEC_ID_NONE,
308  .video_codec = AV_CODEC_ID_H261,
309  .write_header = force_one_stream,
310  .write_packet = ff_raw_write_packet,
311  .flags = AVFMT_NOTIMESTAMPS,
312 };
313 #endif
314 
315 #if CONFIG_H263_MUXER
316 AVOutputFormat ff_h263_muxer = {
317  .name = "h263",
318  .long_name = NULL_IF_CONFIG_SMALL("raw H.263"),
319  .mime_type = "video/x-h263",
320  .extensions = "h263",
321  .audio_codec = AV_CODEC_ID_NONE,
322  .video_codec = AV_CODEC_ID_H263,
323  .write_header = force_one_stream,
324  .write_packet = ff_raw_write_packet,
325  .flags = AVFMT_NOTIMESTAMPS,
326 };
327 #endif
328 
329 #if CONFIG_H264_MUXER
330 static int h264_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
331 {
332  AVStream *st = s->streams[0];
333  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
334  AV_RB24(pkt->data) != 0x000001)
335  return ff_stream_add_bitstream_filter(st, "h264_mp4toannexb", NULL);
336  return 1;
337 }
338 
339 AVOutputFormat ff_h264_muxer = {
340  .name = "h264",
341  .long_name = NULL_IF_CONFIG_SMALL("raw H.264 video"),
342  .extensions = "h264,264",
343  .audio_codec = AV_CODEC_ID_NONE,
344  .video_codec = AV_CODEC_ID_H264,
345  .write_header = force_one_stream,
346  .write_packet = ff_raw_write_packet,
347  .check_bitstream = h264_check_bitstream,
348  .flags = AVFMT_NOTIMESTAMPS,
349 };
350 #endif
351 
352 #if CONFIG_HEVC_MUXER
353 static int hevc_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
354 {
355  AVStream *st = s->streams[0];
356  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
357  AV_RB24(pkt->data) != 0x000001)
358  return ff_stream_add_bitstream_filter(st, "hevc_mp4toannexb", NULL);
359  return 1;
360 }
361 
362 AVOutputFormat ff_hevc_muxer = {
363  .name = "hevc",
364  .long_name = NULL_IF_CONFIG_SMALL("raw HEVC video"),
365  .extensions = "hevc,h265,265",
366  .audio_codec = AV_CODEC_ID_NONE,
367  .video_codec = AV_CODEC_ID_HEVC,
368  .write_header = force_one_stream,
369  .write_packet = ff_raw_write_packet,
370  .check_bitstream = hevc_check_bitstream,
371  .flags = AVFMT_NOTIMESTAMPS,
372 };
373 #endif
374 
375 #if CONFIG_M4V_MUXER
376 AVOutputFormat ff_m4v_muxer = {
377  .name = "m4v",
378  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-4 video"),
379  .extensions = "m4v",
380  .audio_codec = AV_CODEC_ID_NONE,
381  .video_codec = AV_CODEC_ID_MPEG4,
382  .write_header = force_one_stream,
383  .write_packet = ff_raw_write_packet,
384  .flags = AVFMT_NOTIMESTAMPS,
385 };
386 #endif
387 
388 #if CONFIG_MJPEG_MUXER
389 AVOutputFormat ff_mjpeg_muxer = {
390  .name = "mjpeg",
391  .long_name = NULL_IF_CONFIG_SMALL("raw MJPEG video"),
392  .mime_type = "video/x-mjpeg",
393  .extensions = "mjpg,mjpeg",
394  .audio_codec = AV_CODEC_ID_NONE,
395  .video_codec = AV_CODEC_ID_MJPEG,
396  .write_header = force_one_stream,
397  .write_packet = ff_raw_write_packet,
398  .flags = AVFMT_NOTIMESTAMPS,
399 };
400 #endif
401 
402 #if CONFIG_SINGLEJPEG_MUXER
403 AVOutputFormat ff_singlejpeg_muxer = {
404  .name = "singlejpeg",
405  .long_name = NULL_IF_CONFIG_SMALL("JPEG single image"),
406  .mime_type = "image/jpeg",
407  .audio_codec = AV_CODEC_ID_NONE,
408  .video_codec = AV_CODEC_ID_MJPEG,
409  .write_packet = ff_raw_write_packet,
410  .flags = AVFMT_NOTIMESTAMPS,
411  .write_header = force_one_stream,
412 };
413 #endif
414 
415 #if CONFIG_MLP_MUXER
416 AVOutputFormat ff_mlp_muxer = {
417  .name = "mlp",
418  .long_name = NULL_IF_CONFIG_SMALL("raw MLP"),
419  .extensions = "mlp",
420  .audio_codec = AV_CODEC_ID_MLP,
421  .video_codec = AV_CODEC_ID_NONE,
422  .write_header = force_one_stream,
423  .write_packet = ff_raw_write_packet,
424  .flags = AVFMT_NOTIMESTAMPS,
425 };
426 #endif
427 
428 #if CONFIG_MP2_MUXER
429 AVOutputFormat ff_mp2_muxer = {
430  .name = "mp2",
431  .long_name = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
432  .mime_type = "audio/mpeg",
433  .extensions = "mp2,m2a,mpa",
434  .audio_codec = AV_CODEC_ID_MP2,
435  .video_codec = AV_CODEC_ID_NONE,
436  .write_packet = ff_raw_write_packet,
437  .flags = AVFMT_NOTIMESTAMPS,
438 };
439 #endif
440 
441 #if CONFIG_MPEG1VIDEO_MUXER
442 AVOutputFormat ff_mpeg1video_muxer = {
443  .name = "mpeg1video",
444  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
445  .mime_type = "video/mpeg",
446  .extensions = "mpg,mpeg,m1v",
447  .audio_codec = AV_CODEC_ID_NONE,
448  .video_codec = AV_CODEC_ID_MPEG1VIDEO,
449  .write_header = force_one_stream,
450  .write_packet = ff_raw_write_packet,
451  .flags = AVFMT_NOTIMESTAMPS,
452 };
453 #endif
454 
455 #if CONFIG_MPEG2VIDEO_MUXER
456 AVOutputFormat ff_mpeg2video_muxer = {
457  .name = "mpeg2video",
458  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
459  .extensions = "m2v",
460  .audio_codec = AV_CODEC_ID_NONE,
461  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
462  .write_header = force_one_stream,
463  .write_packet = ff_raw_write_packet,
464  .flags = AVFMT_NOTIMESTAMPS,
465 };
466 #endif
467 
468 #if CONFIG_RAWVIDEO_MUXER
469 AVOutputFormat ff_rawvideo_muxer = {
470  .name = "rawvideo",
471  .long_name = NULL_IF_CONFIG_SMALL("raw video"),
472  .extensions = "yuv,rgb",
473  .audio_codec = AV_CODEC_ID_NONE,
474  .video_codec = AV_CODEC_ID_RAWVIDEO,
475  .write_packet = ff_raw_write_packet,
476  .flags = AVFMT_NOTIMESTAMPS,
477 };
478 #endif
479 
480 #if CONFIG_SBC_MUXER
481 AVOutputFormat ff_sbc_muxer = {
482  .name = "sbc",
483  .long_name = NULL_IF_CONFIG_SMALL("raw SBC"),
484  .mime_type = "audio/x-sbc",
485  .extensions = "sbc,msbc",
486  .audio_codec = AV_CODEC_ID_SBC,
487  .write_header = force_one_stream,
488  .write_packet = ff_raw_write_packet,
489  .flags = AVFMT_NOTIMESTAMPS,
490 };
491 #endif
492 
493 #if CONFIG_TRUEHD_MUXER
494 AVOutputFormat ff_truehd_muxer = {
495  .name = "truehd",
496  .long_name = NULL_IF_CONFIG_SMALL("raw TrueHD"),
497  .extensions = "thd",
498  .audio_codec = AV_CODEC_ID_TRUEHD,
499  .video_codec = AV_CODEC_ID_NONE,
500  .write_header = force_one_stream,
501  .write_packet = ff_raw_write_packet,
502  .flags = AVFMT_NOTIMESTAMPS,
503 };
504 #endif
505 
506 #if CONFIG_VC1_MUXER
507 AVOutputFormat ff_vc1_muxer = {
508  .name = "vc1",
509  .long_name = NULL_IF_CONFIG_SMALL("raw VC-1 video"),
510  .extensions = "vc1",
511  .audio_codec = AV_CODEC_ID_NONE,
512  .video_codec = AV_CODEC_ID_VC1,
513  .write_header = force_one_stream,
514  .write_packet = ff_raw_write_packet,
515  .flags = AVFMT_NOTIMESTAMPS,
516 };
517 #endif
ff_mpeg2video_muxer
AVOutputFormat ff_mpeg2video_muxer
ff_vc1_muxer
AVOutputFormat ff_vc1_muxer
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:413
AVOutputFormat::name
const char * name
Definition: avformat.h:491
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
ff_aptx_muxer
AVOutputFormat ff_aptx_muxer
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:165
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:62
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
ff_ac3_muxer
AVOutputFormat ff_ac3_muxer
ff_h263_muxer
AVOutputFormat ff_h263_muxer
ff_h264_muxer
AVOutputFormat ff_h264_muxer
AVPacket::data
uint8_t * data
Definition: packet.h:355
AV_CODEC_ID_AVS2
@ AV_CODEC_ID_AVS2
Definition: codec_id.h:243
ff_aptx_hd_muxer
AVOutputFormat ff_aptx_hd_muxer
ff_singlejpeg_muxer
AVOutputFormat ff_singlejpeg_muxer
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:368
ff_cavsvideo_muxer
AVOutputFormat ff_cavsvideo_muxer
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:454
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:52
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
ff_dnxhd_muxer
AVOutputFormat ff_dnxhd_muxer
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
ff_m4v_muxer
AVOutputFormat ff_m4v_muxer
AV_CODEC_ID_SBC
@ AV_CODEC_ID_SBC
Definition: codec_id.h:498
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:351
ff_g726_muxer
AVOutputFormat ff_g726_muxer
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:410
ff_raw_write_packet
int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rawenc.c:29
ff_avs2_muxer
AVOutputFormat ff_avs2_muxer
AV_CODEC_ID_CODEC2
@ AV_CODEC_ID_CODEC2
Definition: codec_id.h:477
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
internal.h
NULL
#define NULL
Definition: coverity.c:32
force_one_stream
static int force_one_stream(AVFormatContext *s)
Definition: rawenc.c:35
ff_truehd_muxer
AVOutputFormat ff_truehd_muxer
AV_CODEC_ID_G723_1
@ AV_CODEC_ID_G723_1
Definition: codec_id.h:462
ff_g726le_muxer
AVOutputFormat ff_g726le_muxer
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: utils.c:5579
ff_data_muxer
AVOutputFormat ff_data_muxer
ff_dirac_muxer
AVOutputFormat ff_dirac_muxer
ff_mpeg1video_muxer
AVOutputFormat ff_mpeg1video_muxer
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:50
AV_CODEC_ID_GSM
@ AV_CODEC_ID_GSM
as in Berlin toast format
Definition: codec_id.h:428
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:450
ff_mp2_muxer
AVOutputFormat ff_mp2_muxer
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AV_CODEC_ID_ADPCM_ADX
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:349
AVPacket::size
int size
Definition: packet.h:356
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:188
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
ff_mlp_muxer
AVOutputFormat ff_mlp_muxer
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:414
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:53
AV_RB32
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_RB32
Definition: bytestream.h:92
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:213
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
ff_h261_muxer
AVOutputFormat ff_h261_muxer
rawenc.h
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
AVOutputFormat
Definition: avformat.h:490
ff_codec2raw_muxer
AVOutputFormat ff_codec2raw_muxer
AV_CODEC_ID_CAVS
@ AV_CODEC_ID_CAVS
Definition: codec_id.h:136
ff_adx_muxer
AVOutputFormat ff_adx_muxer
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:119
ff_hevc_muxer
AVOutputFormat ff_hevc_muxer
AVStream
Stream structure.
Definition: avformat.h:865
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
avformat.h
ff_rawvideo_muxer
AVOutputFormat ff_rawvideo_muxer
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:376
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
ff_gsm_muxer
AVOutputFormat ff_gsm_muxer
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_sbc_muxer
AVOutputFormat ff_sbc_muxer
ff_eac3_muxer
AVOutputFormat ff_eac3_muxer
ff_g723_1_muxer
AVOutputFormat ff_g723_1_muxer
AVPacket
This structure stores compressed data.
Definition: packet.h:332
ff_dts_muxer
AVOutputFormat ff_dts_muxer
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_CODEC_ID_APTX
@ AV_CODEC_ID_APTX
Definition: codec_id.h:496
AV_RB24
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_RB24
Definition: bytestream.h:93
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
AV_CODEC_ID_APTX_HD
@ AV_CODEC_ID_APTX_HD
Definition: codec_id.h:497
AV_CODEC_ID_DNXHD
@ AV_CODEC_ID_DNXHD
Definition: codec_id.h:148
AV_CODEC_ID_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:439
ff_mjpeg_muxer
AVOutputFormat ff_mjpeg_muxer
ff_g722_muxer
AVOutputFormat ff_g722_muxer
Generated on Wed Aug 24 2022 21:31:32 for FFmpeg by   doxygen 1.8.17