ffmpeg / libavformat / raw.c @ 9106a698
History | View | Annotate | Download (30 KB)
1 |
/*
|
---|---|
2 |
* RAW muxer and demuxer
|
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/crc.h" |
24 |
#include "libavcodec/ac3_parser.h" |
25 |
#include "libavcodec/get_bits.h" |
26 |
#include "libavcodec/bytestream.h" |
27 |
#include "avformat.h" |
28 |
#include "raw.h" |
29 |
#include "id3v2.h" |
30 |
|
31 |
/* simple formats */
|
32 |
|
33 |
#if CONFIG_ROQ_MUXER
|
34 |
static int roq_write_header(struct AVFormatContext *s) |
35 |
{ |
36 |
static const uint8_t header[] = { |
37 |
0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00 |
38 |
}; |
39 |
|
40 |
put_buffer(s->pb, header, 8);
|
41 |
put_flush_packet(s->pb); |
42 |
|
43 |
return 0; |
44 |
} |
45 |
#endif
|
46 |
|
47 |
#if CONFIG_NULL_MUXER
|
48 |
static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt) |
49 |
{ |
50 |
return 0; |
51 |
} |
52 |
#endif
|
53 |
|
54 |
#if CONFIG_MUXERS
|
55 |
static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt) |
56 |
{ |
57 |
put_buffer(s->pb, pkt->data, pkt->size); |
58 |
put_flush_packet(s->pb); |
59 |
return 0; |
60 |
} |
61 |
#endif
|
62 |
|
63 |
#if CONFIG_DEMUXERS
|
64 |
/* raw input */
|
65 |
static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap) |
66 |
{ |
67 |
AVStream *st; |
68 |
int id;
|
69 |
|
70 |
st = av_new_stream(s, 0);
|
71 |
if (!st)
|
72 |
return AVERROR(ENOMEM);
|
73 |
|
74 |
id = s->iformat->value; |
75 |
if (id == CODEC_ID_RAWVIDEO) {
|
76 |
st->codec->codec_type = CODEC_TYPE_VIDEO; |
77 |
} else {
|
78 |
st->codec->codec_type = CODEC_TYPE_AUDIO; |
79 |
} |
80 |
st->codec->codec_id = id; |
81 |
|
82 |
switch(st->codec->codec_type) {
|
83 |
case CODEC_TYPE_AUDIO:
|
84 |
st->codec->sample_rate = ap->sample_rate; |
85 |
if(ap->channels) st->codec->channels = ap->channels;
|
86 |
else st->codec->channels = 1; |
87 |
st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id); |
88 |
assert(st->codec->bits_per_coded_sample > 0);
|
89 |
st->codec->block_align = st->codec->bits_per_coded_sample*st->codec->channels/8;
|
90 |
av_set_pts_info(st, 64, 1, st->codec->sample_rate); |
91 |
break;
|
92 |
case CODEC_TYPE_VIDEO:
|
93 |
if(ap->time_base.num)
|
94 |
av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
|
95 |
else
|
96 |
av_set_pts_info(st, 64, 1, 25); |
97 |
st->codec->width = ap->width; |
98 |
st->codec->height = ap->height; |
99 |
st->codec->pix_fmt = ap->pix_fmt; |
100 |
if(st->codec->pix_fmt == PIX_FMT_NONE)
|
101 |
st->codec->pix_fmt= PIX_FMT_YUV420P; |
102 |
break;
|
103 |
default:
|
104 |
return -1; |
105 |
} |
106 |
return 0; |
107 |
} |
108 |
|
109 |
#define RAW_PACKET_SIZE 1024 |
110 |
#define RAW_SAMPLES 1024 |
111 |
|
112 |
static int raw_read_packet(AVFormatContext *s, AVPacket *pkt) |
113 |
{ |
114 |
int ret, size, bps;
|
115 |
// AVStream *st = s->streams[0];
|
116 |
|
117 |
size= RAW_SAMPLES*s->streams[0]->codec->block_align;
|
118 |
|
119 |
ret= av_get_packet(s->pb, pkt, size); |
120 |
|
121 |
pkt->stream_index = 0;
|
122 |
if (ret <= 0) { |
123 |
return AVERROR(EIO);
|
124 |
} |
125 |
/* note: we need to modify the packet size here to handle the last
|
126 |
packet */
|
127 |
pkt->size = ret; |
128 |
|
129 |
bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id);
|
130 |
assert(bps); // if false there IS a bug elsewhere (NOT in this function)
|
131 |
pkt->dts= |
132 |
pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels); |
133 |
|
134 |
return ret;
|
135 |
} |
136 |
|
137 |
int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
|
138 |
{ |
139 |
int ret, size;
|
140 |
|
141 |
size = RAW_PACKET_SIZE; |
142 |
|
143 |
if (av_new_packet(pkt, size) < 0) |
144 |
return AVERROR(EIO);
|
145 |
|
146 |
pkt->pos= url_ftell(s->pb); |
147 |
pkt->stream_index = 0;
|
148 |
ret = get_partial_buffer(s->pb, pkt->data, size); |
149 |
if (ret <= 0) { |
150 |
av_free_packet(pkt); |
151 |
return AVERROR(EIO);
|
152 |
} |
153 |
pkt->size = ret; |
154 |
return ret;
|
155 |
} |
156 |
#endif
|
157 |
|
158 |
#if CONFIG_RAWVIDEO_DEMUXER
|
159 |
static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt) |
160 |
{ |
161 |
int packet_size, ret, width, height;
|
162 |
AVStream *st = s->streams[0];
|
163 |
|
164 |
width = st->codec->width; |
165 |
height = st->codec->height; |
166 |
|
167 |
packet_size = avpicture_get_size(st->codec->pix_fmt, width, height); |
168 |
if (packet_size < 0) |
169 |
return -1; |
170 |
|
171 |
ret= av_get_packet(s->pb, pkt, packet_size); |
172 |
pkt->pts= |
173 |
pkt->dts= pkt->pos / packet_size; |
174 |
|
175 |
pkt->stream_index = 0;
|
176 |
if (ret != packet_size) {
|
177 |
return AVERROR(EIO);
|
178 |
} else {
|
179 |
return 0; |
180 |
} |
181 |
} |
182 |
#endif
|
183 |
|
184 |
#if CONFIG_INGENIENT_DEMUXER
|
185 |
// http://www.artificis.hu/files/texts/ingenient.txt
|
186 |
static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt) |
187 |
{ |
188 |
int ret, size, w, h, unk1, unk2;
|
189 |
|
190 |
if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G')) |
191 |
return AVERROR(EIO); // FIXME |
192 |
|
193 |
size = get_le32(s->pb); |
194 |
|
195 |
w = get_le16(s->pb); |
196 |
h = get_le16(s->pb); |
197 |
|
198 |
url_fskip(s->pb, 8); // zero + size (padded?) |
199 |
url_fskip(s->pb, 2);
|
200 |
unk1 = get_le16(s->pb); |
201 |
unk2 = get_le16(s->pb); |
202 |
url_fskip(s->pb, 22); // ASCII timestamp |
203 |
|
204 |
av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
|
205 |
size, w, h, unk1, unk2); |
206 |
|
207 |
if (av_new_packet(pkt, size) < 0) |
208 |
return AVERROR(EIO);
|
209 |
|
210 |
pkt->pos = url_ftell(s->pb); |
211 |
pkt->stream_index = 0;
|
212 |
ret = get_buffer(s->pb, pkt->data, size); |
213 |
if (ret <= 0) { |
214 |
av_free_packet(pkt); |
215 |
return AVERROR(EIO);
|
216 |
} |
217 |
pkt->size = ret; |
218 |
return ret;
|
219 |
} |
220 |
#endif
|
221 |
|
222 |
#if CONFIG_DEMUXERS
|
223 |
int pcm_read_seek(AVFormatContext *s,
|
224 |
int stream_index, int64_t timestamp, int flags) |
225 |
{ |
226 |
AVStream *st; |
227 |
int block_align, byte_rate, ret;
|
228 |
int64_t pos; |
229 |
|
230 |
st = s->streams[0];
|
231 |
|
232 |
block_align = st->codec->block_align ? st->codec->block_align : |
233 |
(av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
|
234 |
byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :
|
235 |
block_align * st->codec->sample_rate; |
236 |
|
237 |
if (block_align <= 0 || byte_rate <= 0) |
238 |
return -1; |
239 |
if (timestamp < 0) timestamp = 0; |
240 |
|
241 |
/* compute the position by aligning it to block_align */
|
242 |
pos = av_rescale_rnd(timestamp * byte_rate, |
243 |
st->time_base.num, |
244 |
st->time_base.den * (int64_t)block_align, |
245 |
(flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP); |
246 |
pos *= block_align; |
247 |
|
248 |
/* recompute exact position */
|
249 |
st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num); |
250 |
if ((ret = url_fseek(s->pb, pos + s->data_offset, SEEK_SET)) < 0) |
251 |
return ret;
|
252 |
return 0; |
253 |
} |
254 |
|
255 |
static int audio_read_header(AVFormatContext *s, |
256 |
AVFormatParameters *ap) |
257 |
{ |
258 |
AVStream *st = av_new_stream(s, 0);
|
259 |
if (!st)
|
260 |
return AVERROR(ENOMEM);
|
261 |
st->codec->codec_type = CODEC_TYPE_AUDIO; |
262 |
st->codec->codec_id = s->iformat->value; |
263 |
st->need_parsing = AVSTREAM_PARSE_FULL; |
264 |
/* the parameters will be extracted from the compressed bitstream */
|
265 |
|
266 |
return 0; |
267 |
} |
268 |
|
269 |
/* MPEG-1/H.263 input */
|
270 |
static int video_read_header(AVFormatContext *s, |
271 |
AVFormatParameters *ap) |
272 |
{ |
273 |
AVStream *st; |
274 |
|
275 |
st = av_new_stream(s, 0);
|
276 |
if (!st)
|
277 |
return AVERROR(ENOMEM);
|
278 |
|
279 |
st->codec->codec_type = CODEC_TYPE_VIDEO; |
280 |
st->codec->codec_id = s->iformat->value; |
281 |
st->need_parsing = AVSTREAM_PARSE_FULL; |
282 |
|
283 |
/* for MJPEG, specify frame rate */
|
284 |
/* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop_rate set ...)*/
|
285 |
if (ap->time_base.num) {
|
286 |
st->codec->time_base= ap->time_base; |
287 |
} else if ( st->codec->codec_id == CODEC_ID_MJPEG || |
288 |
st->codec->codec_id == CODEC_ID_MPEG4 || |
289 |
st->codec->codec_id == CODEC_ID_DIRAC || |
290 |
st->codec->codec_id == CODEC_ID_H264) { |
291 |
st->codec->time_base= (AVRational){1,25}; |
292 |
} |
293 |
av_set_pts_info(st, 64, 1, 1200000); |
294 |
|
295 |
return 0; |
296 |
} |
297 |
#endif
|
298 |
|
299 |
#if CONFIG_MPEGVIDEO_DEMUXER
|
300 |
#define SEQ_START_CODE 0x000001b3 |
301 |
#define GOP_START_CODE 0x000001b8 |
302 |
#define PICTURE_START_CODE 0x00000100 |
303 |
#define SLICE_START_CODE 0x00000101 |
304 |
#define PACK_START_CODE 0x000001ba |
305 |
#define VIDEO_ID 0x000001e0 |
306 |
#define AUDIO_ID 0x000001c0 |
307 |
|
308 |
static int mpegvideo_probe(AVProbeData *p) |
309 |
{ |
310 |
uint32_t code= -1;
|
311 |
int pic=0, seq=0, slice=0, pspack=0, pes=0; |
312 |
int i;
|
313 |
|
314 |
for(i=0; i<p->buf_size; i++){ |
315 |
code = (code<<8) + p->buf[i];
|
316 |
if ((code & 0xffffff00) == 0x100) { |
317 |
switch(code){
|
318 |
case SEQ_START_CODE: seq++; break; |
319 |
case PICTURE_START_CODE: pic++; break; |
320 |
case SLICE_START_CODE: slice++; break; |
321 |
case PACK_START_CODE: pspack++; break; |
322 |
} |
323 |
if ((code & 0x1f0) == VIDEO_ID) pes++; |
324 |
else if((code & 0x1e0) == AUDIO_ID) pes++; |
325 |
} |
326 |
} |
327 |
if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes) |
328 |
return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg |
329 |
return 0; |
330 |
} |
331 |
|
332 |
#define CAVS_SEQ_START_CODE 0x000001b0 |
333 |
#define CAVS_PIC_I_START_CODE 0x000001b3 |
334 |
#define CAVS_UNDEF_START_CODE 0x000001b4 |
335 |
#define CAVS_PIC_PB_START_CODE 0x000001b6 |
336 |
#define CAVS_VIDEO_EDIT_CODE 0x000001b7 |
337 |
#define CAVS_PROFILE_JIZHUN 0x20 |
338 |
|
339 |
static int cavsvideo_probe(AVProbeData *p) |
340 |
{ |
341 |
uint32_t code= -1;
|
342 |
int pic=0, seq=0, slice_pos = 0; |
343 |
int i;
|
344 |
|
345 |
for(i=0; i<p->buf_size; i++){ |
346 |
code = (code<<8) + p->buf[i];
|
347 |
if ((code & 0xffffff00) == 0x100) { |
348 |
if(code < CAVS_SEQ_START_CODE) {
|
349 |
/* slices have to be consecutive */
|
350 |
if(code < slice_pos)
|
351 |
return 0; |
352 |
slice_pos = code; |
353 |
} else {
|
354 |
slice_pos = 0;
|
355 |
} |
356 |
if (code == CAVS_SEQ_START_CODE) {
|
357 |
seq++; |
358 |
/* check for the only currently supported profile */
|
359 |
if(p->buf[i+1] != CAVS_PROFILE_JIZHUN) |
360 |
return 0; |
361 |
} else if ((code == CAVS_PIC_I_START_CODE) || |
362 |
(code == CAVS_PIC_PB_START_CODE)) { |
363 |
pic++; |
364 |
} else if ((code == CAVS_UNDEF_START_CODE) || |
365 |
(code > CAVS_VIDEO_EDIT_CODE)) { |
366 |
return 0; |
367 |
} |
368 |
} |
369 |
} |
370 |
if(seq && seq*9<=pic*10) |
371 |
return AVPROBE_SCORE_MAX/2; |
372 |
return 0; |
373 |
} |
374 |
#endif
|
375 |
|
376 |
#if CONFIG_M4V_DEMUXER
|
377 |
#define VISUAL_OBJECT_START_CODE 0x000001b5 |
378 |
#define VOP_START_CODE 0x000001b6 |
379 |
|
380 |
static int mpeg4video_probe(AVProbeData *probe_packet) |
381 |
{ |
382 |
uint32_t temp_buffer= -1;
|
383 |
int VO=0, VOL=0, VOP = 0, VISO = 0, res=0; |
384 |
int i;
|
385 |
|
386 |
for(i=0; i<probe_packet->buf_size; i++){ |
387 |
temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];
|
388 |
if ((temp_buffer & 0xffffff00) != 0x100) |
389 |
continue;
|
390 |
|
391 |
if (temp_buffer == VOP_START_CODE) VOP++;
|
392 |
else if (temp_buffer == VISUAL_OBJECT_START_CODE) VISO++; |
393 |
else if (temp_buffer < 0x120) VO++; |
394 |
else if (temp_buffer < 0x130) VOL++; |
395 |
else if ( !(0x1AF < temp_buffer && temp_buffer < 0x1B7) |
396 |
&& !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++; |
397 |
} |
398 |
|
399 |
if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0) |
400 |
return AVPROBE_SCORE_MAX/2; |
401 |
return 0; |
402 |
} |
403 |
#endif
|
404 |
|
405 |
#if CONFIG_H264_DEMUXER
|
406 |
static int h264_probe(AVProbeData *p) |
407 |
{ |
408 |
uint32_t code= -1;
|
409 |
int sps=0, pps=0, idr=0, res=0, sli=0; |
410 |
int i;
|
411 |
|
412 |
for(i=0; i<p->buf_size; i++){ |
413 |
code = (code<<8) + p->buf[i];
|
414 |
if ((code & 0xffffff00) == 0x100) { |
415 |
int ref_idc= (code>>5)&3; |
416 |
int type = code & 0x1F; |
417 |
static const int8_t ref_zero[32]={ |
418 |
2, 0, 0, 0, 0,-1, 1,-1, |
419 |
-1, 1, 1, 1, 1,-1, 2, 2, |
420 |
2, 2, 2, 0, 2, 2, 2, 2, |
421 |
2, 2, 2, 2, 2, 2, 2, 2 |
422 |
}; |
423 |
|
424 |
if(code & 0x80) //forbidden bit |
425 |
return 0; |
426 |
|
427 |
if(ref_zero[type] == 1 && ref_idc) |
428 |
return 0; |
429 |
if(ref_zero[type] ==-1 && !ref_idc) |
430 |
return 0; |
431 |
if(ref_zero[type] == 2) |
432 |
res++; |
433 |
|
434 |
switch(type){
|
435 |
case 1: sli++; break; |
436 |
case 5: idr++; break; |
437 |
case 7: |
438 |
if(p->buf[i+2]&0x0F) |
439 |
return 0; |
440 |
sps++; |
441 |
break;
|
442 |
case 8: pps++; break; |
443 |
} |
444 |
} |
445 |
} |
446 |
if(sps && pps && (idr||sli>3) && res<(sps+pps+idr)) |
447 |
return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg |
448 |
return 0; |
449 |
} |
450 |
#endif
|
451 |
|
452 |
#if CONFIG_H263_DEMUXER
|
453 |
static int h263_probe(AVProbeData *p) |
454 |
{ |
455 |
int code;
|
456 |
const uint8_t *d;
|
457 |
|
458 |
d = p->buf; |
459 |
code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2); |
460 |
if (code == 0x20) { |
461 |
return 50; |
462 |
} |
463 |
return 0; |
464 |
} |
465 |
#endif
|
466 |
|
467 |
#if CONFIG_H261_DEMUXER
|
468 |
static int h261_probe(AVProbeData *p) |
469 |
{ |
470 |
int code;
|
471 |
const uint8_t *d;
|
472 |
|
473 |
d = p->buf; |
474 |
code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4); |
475 |
if (code == 0x10) { |
476 |
return 50; |
477 |
} |
478 |
return 0; |
479 |
} |
480 |
#endif
|
481 |
|
482 |
#if CONFIG_DTS_DEMUXER
|
483 |
#define DCA_MARKER_14B_BE 0x1FFFE800 |
484 |
#define DCA_MARKER_14B_LE 0xFF1F00E8 |
485 |
#define DCA_MARKER_RAW_BE 0x7FFE8001 |
486 |
#define DCA_MARKER_RAW_LE 0xFE7F0180 |
487 |
static int dts_probe(AVProbeData *p) |
488 |
{ |
489 |
const uint8_t *buf, *bufp;
|
490 |
uint32_t state = -1;
|
491 |
|
492 |
buf = p->buf; |
493 |
|
494 |
for(; buf < (p->buf+p->buf_size)-2; buf+=2) { |
495 |
bufp = buf; |
496 |
state = (state << 16) | bytestream_get_be16(&bufp);
|
497 |
|
498 |
/* regular bitstream */
|
499 |
if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)
|
500 |
return AVPROBE_SCORE_MAX/2+1; |
501 |
|
502 |
/* 14 bits big-endian bitstream */
|
503 |
if (state == DCA_MARKER_14B_BE)
|
504 |
if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0) |
505 |
return AVPROBE_SCORE_MAX/2+1; |
506 |
|
507 |
/* 14 bits little-endian bitstream */
|
508 |
if (state == DCA_MARKER_14B_LE)
|
509 |
if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007) |
510 |
return AVPROBE_SCORE_MAX/2+1; |
511 |
} |
512 |
|
513 |
return 0; |
514 |
} |
515 |
#endif
|
516 |
|
517 |
#if CONFIG_DIRAC_DEMUXER
|
518 |
static int dirac_probe(AVProbeData *p) |
519 |
{ |
520 |
if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D')) |
521 |
return AVPROBE_SCORE_MAX;
|
522 |
else
|
523 |
return 0; |
524 |
} |
525 |
#endif
|
526 |
|
527 |
#if CONFIG_DNXHD_DEMUXER
|
528 |
static int dnxhd_probe(AVProbeData *p) |
529 |
{ |
530 |
static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01}; |
531 |
if (!memcmp(p->buf, header, 5)) |
532 |
return AVPROBE_SCORE_MAX;
|
533 |
else
|
534 |
return 0; |
535 |
} |
536 |
#endif
|
537 |
|
538 |
#if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER
|
539 |
static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id) |
540 |
{ |
541 |
int max_frames, first_frames = 0, frames; |
542 |
uint8_t *buf, *buf2, *end; |
543 |
AC3HeaderInfo hdr; |
544 |
GetBitContext gbc; |
545 |
enum CodecID codec_id = CODEC_ID_AC3;
|
546 |
|
547 |
max_frames = 0;
|
548 |
buf = p->buf; |
549 |
end = buf + p->buf_size; |
550 |
|
551 |
for(; buf < end; buf++) {
|
552 |
buf2 = buf; |
553 |
|
554 |
for(frames = 0; buf2 < end; frames++) { |
555 |
init_get_bits(&gbc, buf2, 54);
|
556 |
if(ff_ac3_parse_header(&gbc, &hdr) < 0) |
557 |
break;
|
558 |
if(buf2 + hdr.frame_size > end ||
|
559 |
av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2)) |
560 |
break;
|
561 |
if (hdr.bitstream_id > 10) |
562 |
codec_id = CODEC_ID_EAC3; |
563 |
buf2 += hdr.frame_size; |
564 |
} |
565 |
max_frames = FFMAX(max_frames, frames); |
566 |
if(buf == p->buf)
|
567 |
first_frames = frames; |
568 |
} |
569 |
if(codec_id != expected_codec_id) return 0; |
570 |
if (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4; |
571 |
else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2; |
572 |
else if(max_frames>=1) return 1; |
573 |
else return 0; |
574 |
} |
575 |
#endif
|
576 |
|
577 |
#if CONFIG_AC3_DEMUXER
|
578 |
static int ac3_probe(AVProbeData *p) |
579 |
{ |
580 |
return ac3_eac3_probe(p, CODEC_ID_AC3);
|
581 |
} |
582 |
#endif
|
583 |
|
584 |
#if CONFIG_EAC3_DEMUXER
|
585 |
static int eac3_probe(AVProbeData *p) |
586 |
{ |
587 |
return ac3_eac3_probe(p, CODEC_ID_EAC3);
|
588 |
} |
589 |
#endif
|
590 |
|
591 |
#if CONFIG_AAC_DEMUXER
|
592 |
static int adts_aac_probe(AVProbeData *p) |
593 |
{ |
594 |
int max_frames = 0, first_frames = 0; |
595 |
int fsize, frames;
|
596 |
uint8_t *buf0 = p->buf; |
597 |
uint8_t *buf2; |
598 |
uint8_t *buf; |
599 |
uint8_t *end = buf0 + p->buf_size - 7;
|
600 |
|
601 |
if (ff_id3v2_match(buf0)) {
|
602 |
buf0 += ff_id3v2_tag_len(buf0); |
603 |
} |
604 |
buf = buf0; |
605 |
|
606 |
for(; buf < end; buf= buf2+1) { |
607 |
buf2 = buf; |
608 |
|
609 |
for(frames = 0; buf2 < end; frames++) { |
610 |
uint32_t header = AV_RB16(buf2); |
611 |
if((header&0xFFF6) != 0xFFF0) |
612 |
break;
|
613 |
fsize = (AV_RB32(buf2+3)>>13) & 0x8FFF; |
614 |
if(fsize < 7) |
615 |
break;
|
616 |
buf2 += fsize; |
617 |
} |
618 |
max_frames = FFMAX(max_frames, frames); |
619 |
if(buf == buf0)
|
620 |
first_frames= frames; |
621 |
} |
622 |
if (first_frames>=3) return AVPROBE_SCORE_MAX/2+1; |
623 |
else if(max_frames>500)return AVPROBE_SCORE_MAX/2; |
624 |
else if(max_frames>=3) return AVPROBE_SCORE_MAX/4; |
625 |
else if(max_frames>=1) return 1; |
626 |
else return 0; |
627 |
} |
628 |
#endif
|
629 |
|
630 |
/* Note: Do not forget to add new entries to the Makefile as well. */
|
631 |
|
632 |
#if CONFIG_AAC_DEMUXER
|
633 |
AVInputFormat aac_demuxer = { |
634 |
"aac",
|
635 |
NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
|
636 |
0,
|
637 |
adts_aac_probe, |
638 |
audio_read_header, |
639 |
ff_raw_read_partial_packet, |
640 |
.flags= AVFMT_GENERIC_INDEX, |
641 |
.extensions = "aac",
|
642 |
.value = CODEC_ID_AAC, |
643 |
}; |
644 |
#endif
|
645 |
|
646 |
#if CONFIG_AC3_DEMUXER
|
647 |
AVInputFormat ac3_demuxer = { |
648 |
"ac3",
|
649 |
NULL_IF_CONFIG_SMALL("raw AC-3"),
|
650 |
0,
|
651 |
ac3_probe, |
652 |
audio_read_header, |
653 |
ff_raw_read_partial_packet, |
654 |
.flags= AVFMT_GENERIC_INDEX, |
655 |
.extensions = "ac3",
|
656 |
.value = CODEC_ID_AC3, |
657 |
}; |
658 |
#endif
|
659 |
|
660 |
#if CONFIG_AC3_MUXER
|
661 |
AVOutputFormat ac3_muxer = { |
662 |
"ac3",
|
663 |
NULL_IF_CONFIG_SMALL("raw AC-3"),
|
664 |
"audio/x-ac3",
|
665 |
"ac3",
|
666 |
0,
|
667 |
CODEC_ID_AC3, |
668 |
CODEC_ID_NONE, |
669 |
NULL,
|
670 |
raw_write_packet, |
671 |
.flags= AVFMT_NOTIMESTAMPS, |
672 |
}; |
673 |
#endif
|
674 |
|
675 |
#if CONFIG_DIRAC_DEMUXER
|
676 |
AVInputFormat dirac_demuxer = { |
677 |
"dirac",
|
678 |
NULL_IF_CONFIG_SMALL("raw Dirac"),
|
679 |
0,
|
680 |
dirac_probe, |
681 |
video_read_header, |
682 |
ff_raw_read_partial_packet, |
683 |
.flags= AVFMT_GENERIC_INDEX, |
684 |
.value = CODEC_ID_DIRAC, |
685 |
}; |
686 |
#endif
|
687 |
|
688 |
#if CONFIG_DIRAC_MUXER
|
689 |
AVOutputFormat dirac_muxer = { |
690 |
"dirac",
|
691 |
NULL_IF_CONFIG_SMALL("raw Dirac"),
|
692 |
NULL,
|
693 |
"drc",
|
694 |
0,
|
695 |
CODEC_ID_NONE, |
696 |
CODEC_ID_DIRAC, |
697 |
NULL,
|
698 |
raw_write_packet, |
699 |
.flags= AVFMT_NOTIMESTAMPS, |
700 |
}; |
701 |
#endif
|
702 |
|
703 |
#if CONFIG_DNXHD_DEMUXER
|
704 |
AVInputFormat dnxhd_demuxer = { |
705 |
"dnxhd",
|
706 |
NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
|
707 |
0,
|
708 |
dnxhd_probe, |
709 |
video_read_header, |
710 |
ff_raw_read_partial_packet, |
711 |
.flags= AVFMT_GENERIC_INDEX, |
712 |
.value = CODEC_ID_DNXHD, |
713 |
}; |
714 |
#endif
|
715 |
|
716 |
#if CONFIG_DNXHD_MUXER
|
717 |
AVOutputFormat dnxhd_muxer = { |
718 |
"dnxhd",
|
719 |
NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
|
720 |
NULL,
|
721 |
"dnxhd",
|
722 |
0,
|
723 |
CODEC_ID_NONE, |
724 |
CODEC_ID_DNXHD, |
725 |
NULL,
|
726 |
raw_write_packet, |
727 |
.flags= AVFMT_NOTIMESTAMPS, |
728 |
}; |
729 |
#endif
|
730 |
|
731 |
#if CONFIG_DTS_DEMUXER
|
732 |
AVInputFormat dts_demuxer = { |
733 |
"dts",
|
734 |
NULL_IF_CONFIG_SMALL("raw DTS"),
|
735 |
0,
|
736 |
dts_probe, |
737 |
audio_read_header, |
738 |
ff_raw_read_partial_packet, |
739 |
.flags= AVFMT_GENERIC_INDEX, |
740 |
.extensions = "dts",
|
741 |
.value = CODEC_ID_DTS, |
742 |
}; |
743 |
#endif
|
744 |
|
745 |
#if CONFIG_DTS_MUXER
|
746 |
AVOutputFormat dts_muxer = { |
747 |
"dts",
|
748 |
NULL_IF_CONFIG_SMALL("raw DTS"),
|
749 |
"audio/x-dca",
|
750 |
"dts",
|
751 |
0,
|
752 |
CODEC_ID_DTS, |
753 |
CODEC_ID_NONE, |
754 |
NULL,
|
755 |
raw_write_packet, |
756 |
.flags= AVFMT_NOTIMESTAMPS, |
757 |
}; |
758 |
#endif
|
759 |
|
760 |
#if CONFIG_EAC3_DEMUXER
|
761 |
AVInputFormat eac3_demuxer = { |
762 |
"eac3",
|
763 |
NULL_IF_CONFIG_SMALL("raw E-AC-3"),
|
764 |
0,
|
765 |
eac3_probe, |
766 |
audio_read_header, |
767 |
ff_raw_read_partial_packet, |
768 |
.flags= AVFMT_GENERIC_INDEX, |
769 |
.extensions = "eac3",
|
770 |
.value = CODEC_ID_EAC3, |
771 |
}; |
772 |
#endif
|
773 |
|
774 |
#if CONFIG_EAC3_MUXER
|
775 |
AVOutputFormat eac3_muxer = { |
776 |
"eac3",
|
777 |
NULL_IF_CONFIG_SMALL("raw E-AC-3"),
|
778 |
"audio/x-eac3",
|
779 |
"eac3",
|
780 |
0,
|
781 |
CODEC_ID_EAC3, |
782 |
CODEC_ID_NONE, |
783 |
NULL,
|
784 |
raw_write_packet, |
785 |
.flags= AVFMT_NOTIMESTAMPS, |
786 |
}; |
787 |
#endif
|
788 |
|
789 |
#if CONFIG_GSM_DEMUXER
|
790 |
AVInputFormat gsm_demuxer = { |
791 |
"gsm",
|
792 |
NULL_IF_CONFIG_SMALL("raw GSM"),
|
793 |
0,
|
794 |
NULL,
|
795 |
audio_read_header, |
796 |
ff_raw_read_partial_packet, |
797 |
.flags= AVFMT_GENERIC_INDEX, |
798 |
.extensions = "gsm",
|
799 |
.value = CODEC_ID_GSM, |
800 |
}; |
801 |
#endif
|
802 |
|
803 |
#if CONFIG_H261_DEMUXER
|
804 |
AVInputFormat h261_demuxer = { |
805 |
"h261",
|
806 |
NULL_IF_CONFIG_SMALL("raw H.261"),
|
807 |
0,
|
808 |
h261_probe, |
809 |
video_read_header, |
810 |
ff_raw_read_partial_packet, |
811 |
.flags= AVFMT_GENERIC_INDEX, |
812 |
.extensions = "h261",
|
813 |
.value = CODEC_ID_H261, |
814 |
}; |
815 |
#endif
|
816 |
|
817 |
#if CONFIG_H261_MUXER
|
818 |
AVOutputFormat h261_muxer = { |
819 |
"h261",
|
820 |
NULL_IF_CONFIG_SMALL("raw H.261"),
|
821 |
"video/x-h261",
|
822 |
"h261",
|
823 |
0,
|
824 |
CODEC_ID_NONE, |
825 |
CODEC_ID_H261, |
826 |
NULL,
|
827 |
raw_write_packet, |
828 |
.flags= AVFMT_NOTIMESTAMPS, |
829 |
}; |
830 |
#endif
|
831 |
|
832 |
#if CONFIG_H263_DEMUXER
|
833 |
AVInputFormat h263_demuxer = { |
834 |
"h263",
|
835 |
NULL_IF_CONFIG_SMALL("raw H.263"),
|
836 |
0,
|
837 |
h263_probe, |
838 |
video_read_header, |
839 |
ff_raw_read_partial_packet, |
840 |
.flags= AVFMT_GENERIC_INDEX, |
841 |
// .extensions = "h263", //FIXME remove after writing mpeg4_probe
|
842 |
.value = CODEC_ID_H263, |
843 |
}; |
844 |
#endif
|
845 |
|
846 |
#if CONFIG_H263_MUXER
|
847 |
AVOutputFormat h263_muxer = { |
848 |
"h263",
|
849 |
NULL_IF_CONFIG_SMALL("raw H.263"),
|
850 |
"video/x-h263",
|
851 |
"h263",
|
852 |
0,
|
853 |
CODEC_ID_NONE, |
854 |
CODEC_ID_H263, |
855 |
NULL,
|
856 |
raw_write_packet, |
857 |
.flags= AVFMT_NOTIMESTAMPS, |
858 |
}; |
859 |
#endif
|
860 |
|
861 |
#if CONFIG_H264_DEMUXER
|
862 |
AVInputFormat h264_demuxer = { |
863 |
"h264",
|
864 |
NULL_IF_CONFIG_SMALL("raw H.264 video format"),
|
865 |
0,
|
866 |
h264_probe, |
867 |
video_read_header, |
868 |
ff_raw_read_partial_packet, |
869 |
.flags= AVFMT_GENERIC_INDEX, |
870 |
.extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe |
871 |
.value = CODEC_ID_H264, |
872 |
}; |
873 |
#endif
|
874 |
|
875 |
#if CONFIG_H264_MUXER
|
876 |
AVOutputFormat h264_muxer = { |
877 |
"h264",
|
878 |
NULL_IF_CONFIG_SMALL("raw H.264 video format"),
|
879 |
NULL,
|
880 |
"h264",
|
881 |
0,
|
882 |
CODEC_ID_NONE, |
883 |
CODEC_ID_H264, |
884 |
NULL,
|
885 |
raw_write_packet, |
886 |
.flags= AVFMT_NOTIMESTAMPS, |
887 |
}; |
888 |
#endif
|
889 |
|
890 |
#if CONFIG_INGENIENT_DEMUXER
|
891 |
AVInputFormat ingenient_demuxer = { |
892 |
"ingenient",
|
893 |
NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
|
894 |
0,
|
895 |
NULL,
|
896 |
video_read_header, |
897 |
ingenient_read_packet, |
898 |
.flags= AVFMT_GENERIC_INDEX, |
899 |
.extensions = "cgi", // FIXME |
900 |
.value = CODEC_ID_MJPEG, |
901 |
}; |
902 |
#endif
|
903 |
|
904 |
#if CONFIG_M4V_DEMUXER
|
905 |
AVInputFormat m4v_demuxer = { |
906 |
"m4v",
|
907 |
NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
|
908 |
0,
|
909 |
mpeg4video_probe, /** probing for MPEG-4 data */
|
910 |
video_read_header, |
911 |
ff_raw_read_partial_packet, |
912 |
.flags= AVFMT_GENERIC_INDEX, |
913 |
.extensions = "m4v",
|
914 |
.value = CODEC_ID_MPEG4, |
915 |
}; |
916 |
#endif
|
917 |
|
918 |
#if CONFIG_M4V_MUXER
|
919 |
AVOutputFormat m4v_muxer = { |
920 |
"m4v",
|
921 |
NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
|
922 |
NULL,
|
923 |
"m4v",
|
924 |
0,
|
925 |
CODEC_ID_NONE, |
926 |
CODEC_ID_MPEG4, |
927 |
NULL,
|
928 |
raw_write_packet, |
929 |
.flags= AVFMT_NOTIMESTAMPS, |
930 |
}; |
931 |
#endif
|
932 |
|
933 |
#if CONFIG_MJPEG_DEMUXER
|
934 |
AVInputFormat mjpeg_demuxer = { |
935 |
"mjpeg",
|
936 |
NULL_IF_CONFIG_SMALL("raw MJPEG video"),
|
937 |
0,
|
938 |
NULL,
|
939 |
video_read_header, |
940 |
ff_raw_read_partial_packet, |
941 |
.flags= AVFMT_GENERIC_INDEX, |
942 |
.extensions = "mjpg,mjpeg",
|
943 |
.value = CODEC_ID_MJPEG, |
944 |
}; |
945 |
#endif
|
946 |
|
947 |
#if CONFIG_MJPEG_MUXER
|
948 |
AVOutputFormat mjpeg_muxer = { |
949 |
"mjpeg",
|
950 |
NULL_IF_CONFIG_SMALL("raw MJPEG video"),
|
951 |
"video/x-mjpeg",
|
952 |
"mjpg,mjpeg",
|
953 |
0,
|
954 |
CODEC_ID_NONE, |
955 |
CODEC_ID_MJPEG, |
956 |
NULL,
|
957 |
raw_write_packet, |
958 |
.flags= AVFMT_NOTIMESTAMPS, |
959 |
}; |
960 |
#endif
|
961 |
|
962 |
#if CONFIG_MLP_DEMUXER
|
963 |
AVInputFormat mlp_demuxer = { |
964 |
"mlp",
|
965 |
NULL_IF_CONFIG_SMALL("raw MLP"),
|
966 |
0,
|
967 |
NULL,
|
968 |
audio_read_header, |
969 |
ff_raw_read_partial_packet, |
970 |
.flags= AVFMT_GENERIC_INDEX, |
971 |
.extensions = "mlp",
|
972 |
.value = CODEC_ID_MLP, |
973 |
}; |
974 |
#endif
|
975 |
|
976 |
#if CONFIG_TRUEHD_DEMUXER
|
977 |
AVInputFormat truehd_demuxer = { |
978 |
"truehd",
|
979 |
NULL_IF_CONFIG_SMALL("raw TrueHD"),
|
980 |
0,
|
981 |
NULL,
|
982 |
audio_read_header, |
983 |
ff_raw_read_partial_packet, |
984 |
.flags= AVFMT_GENERIC_INDEX, |
985 |
.extensions = "thd",
|
986 |
.value = CODEC_ID_TRUEHD, |
987 |
}; |
988 |
#endif
|
989 |
|
990 |
#if CONFIG_TRUEHD_MUXER
|
991 |
AVOutputFormat truehd_muxer = { |
992 |
"truehd",
|
993 |
NULL_IF_CONFIG_SMALL("raw TrueHD"),
|
994 |
NULL,
|
995 |
"thd",
|
996 |
0,
|
997 |
CODEC_ID_TRUEHD, |
998 |
CODEC_ID_NONE, |
999 |
NULL,
|
1000 |
raw_write_packet, |
1001 |
.flags= AVFMT_NOTIMESTAMPS, |
1002 |
}; |
1003 |
#endif
|
1004 |
|
1005 |
#if CONFIG_MPEG1VIDEO_MUXER
|
1006 |
AVOutputFormat mpeg1video_muxer = { |
1007 |
"mpeg1video",
|
1008 |
NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
|
1009 |
"video/x-mpeg",
|
1010 |
"mpg,mpeg,m1v",
|
1011 |
0,
|
1012 |
CODEC_ID_NONE, |
1013 |
CODEC_ID_MPEG1VIDEO, |
1014 |
NULL,
|
1015 |
raw_write_packet, |
1016 |
.flags= AVFMT_NOTIMESTAMPS, |
1017 |
}; |
1018 |
#endif
|
1019 |
|
1020 |
#if CONFIG_MPEG2VIDEO_MUXER
|
1021 |
AVOutputFormat mpeg2video_muxer = { |
1022 |
"mpeg2video",
|
1023 |
NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
|
1024 |
NULL,
|
1025 |
"m2v",
|
1026 |
0,
|
1027 |
CODEC_ID_NONE, |
1028 |
CODEC_ID_MPEG2VIDEO, |
1029 |
NULL,
|
1030 |
raw_write_packet, |
1031 |
.flags= AVFMT_NOTIMESTAMPS, |
1032 |
}; |
1033 |
#endif
|
1034 |
|
1035 |
#if CONFIG_MPEGVIDEO_DEMUXER
|
1036 |
AVInputFormat mpegvideo_demuxer = { |
1037 |
"mpegvideo",
|
1038 |
NULL_IF_CONFIG_SMALL("raw MPEG video"),
|
1039 |
0,
|
1040 |
mpegvideo_probe, |
1041 |
video_read_header, |
1042 |
ff_raw_read_partial_packet, |
1043 |
.flags= AVFMT_GENERIC_INDEX, |
1044 |
.value = CODEC_ID_MPEG1VIDEO, |
1045 |
}; |
1046 |
#endif
|
1047 |
|
1048 |
#if CONFIG_CAVSVIDEO_DEMUXER
|
1049 |
AVInputFormat cavsvideo_demuxer = { |
1050 |
"cavsvideo",
|
1051 |
NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
|
1052 |
0,
|
1053 |
cavsvideo_probe, |
1054 |
video_read_header, |
1055 |
ff_raw_read_partial_packet, |
1056 |
.flags= AVFMT_GENERIC_INDEX, |
1057 |
.value = CODEC_ID_CAVS, |
1058 |
}; |
1059 |
#endif
|
1060 |
|
1061 |
#if CONFIG_NULL_MUXER
|
1062 |
AVOutputFormat null_muxer = { |
1063 |
"null",
|
1064 |
NULL_IF_CONFIG_SMALL("raw null video format"),
|
1065 |
NULL,
|
1066 |
NULL,
|
1067 |
0,
|
1068 |
#ifdef WORDS_BIGENDIAN
|
1069 |
CODEC_ID_PCM_S16BE, |
1070 |
#else
|
1071 |
CODEC_ID_PCM_S16LE, |
1072 |
#endif
|
1073 |
CODEC_ID_RAWVIDEO, |
1074 |
NULL,
|
1075 |
null_write_packet, |
1076 |
.flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS, |
1077 |
}; |
1078 |
#endif
|
1079 |
|
1080 |
#if CONFIG_RAWVIDEO_DEMUXER
|
1081 |
AVInputFormat rawvideo_demuxer = { |
1082 |
"rawvideo",
|
1083 |
NULL_IF_CONFIG_SMALL("raw video format"),
|
1084 |
0,
|
1085 |
NULL,
|
1086 |
raw_read_header, |
1087 |
rawvideo_read_packet, |
1088 |
.flags= AVFMT_GENERIC_INDEX, |
1089 |
.extensions = "yuv,cif,qcif,rgb",
|
1090 |
.value = CODEC_ID_RAWVIDEO, |
1091 |
}; |
1092 |
#endif
|
1093 |
|
1094 |
#if CONFIG_RAWVIDEO_MUXER
|
1095 |
AVOutputFormat rawvideo_muxer = { |
1096 |
"rawvideo",
|
1097 |
NULL_IF_CONFIG_SMALL("raw video format"),
|
1098 |
NULL,
|
1099 |
"yuv,rgb",
|
1100 |
0,
|
1101 |
CODEC_ID_NONE, |
1102 |
CODEC_ID_RAWVIDEO, |
1103 |
NULL,
|
1104 |
raw_write_packet, |
1105 |
.flags= AVFMT_NOTIMESTAMPS, |
1106 |
}; |
1107 |
#endif
|
1108 |
|
1109 |
#if CONFIG_ROQ_MUXER
|
1110 |
AVOutputFormat roq_muxer = |
1111 |
{ |
1112 |
"RoQ",
|
1113 |
NULL_IF_CONFIG_SMALL("raw id RoQ format"),
|
1114 |
NULL,
|
1115 |
"roq",
|
1116 |
0,
|
1117 |
CODEC_ID_ROQ_DPCM, |
1118 |
CODEC_ID_ROQ, |
1119 |
roq_write_header, |
1120 |
raw_write_packet, |
1121 |
}; |
1122 |
#endif
|
1123 |
|
1124 |
#if CONFIG_SHORTEN_DEMUXER
|
1125 |
AVInputFormat shorten_demuxer = { |
1126 |
"shn",
|
1127 |
NULL_IF_CONFIG_SMALL("raw Shorten"),
|
1128 |
0,
|
1129 |
NULL,
|
1130 |
audio_read_header, |
1131 |
ff_raw_read_partial_packet, |
1132 |
.flags= AVFMT_GENERIC_INDEX, |
1133 |
.extensions = "shn",
|
1134 |
.value = CODEC_ID_SHORTEN, |
1135 |
}; |
1136 |
#endif
|
1137 |
|
1138 |
#if CONFIG_VC1_DEMUXER
|
1139 |
AVInputFormat vc1_demuxer = { |
1140 |
"vc1",
|
1141 |
NULL_IF_CONFIG_SMALL("raw VC-1"),
|
1142 |
0,
|
1143 |
NULL /* vc1_probe */, |
1144 |
video_read_header, |
1145 |
ff_raw_read_partial_packet, |
1146 |
.extensions = "vc1",
|
1147 |
.value = CODEC_ID_VC1, |
1148 |
}; |
1149 |
#endif
|
1150 |
|
1151 |
/* PCM formats */
|
1152 |
|
1153 |
#define PCMINPUTDEF(name, long_name, ext, codec) \
|
1154 |
AVInputFormat pcm_ ## name ## _demuxer = {\ |
1155 |
#name,\
|
1156 |
NULL_IF_CONFIG_SMALL(long_name),\ |
1157 |
0,\
|
1158 |
NULL,\
|
1159 |
raw_read_header,\ |
1160 |
raw_read_packet,\ |
1161 |
NULL,\
|
1162 |
pcm_read_seek,\ |
1163 |
.flags= AVFMT_GENERIC_INDEX,\ |
1164 |
.extensions = ext,\ |
1165 |
.value = codec,\ |
1166 |
}; |
1167 |
|
1168 |
#define PCMOUTPUTDEF(name, long_name, ext, codec) \
|
1169 |
AVOutputFormat pcm_ ## name ## _muxer = {\ |
1170 |
#name,\
|
1171 |
NULL_IF_CONFIG_SMALL(long_name),\ |
1172 |
NULL,\
|
1173 |
ext,\ |
1174 |
0,\
|
1175 |
codec,\ |
1176 |
CODEC_ID_NONE,\ |
1177 |
NULL,\
|
1178 |
raw_write_packet,\ |
1179 |
.flags= AVFMT_NOTIMESTAMPS,\ |
1180 |
}; |
1181 |
|
1182 |
|
1183 |
#if !CONFIG_MUXERS && CONFIG_DEMUXERS
|
1184 |
#define PCMDEF(name, long_name, ext, codec) \
|
1185 |
PCMINPUTDEF(name, long_name, ext, codec) |
1186 |
#elif CONFIG_MUXERS && !CONFIG_DEMUXERS
|
1187 |
#define PCMDEF(name, long_name, ext, codec) \
|
1188 |
PCMOUTPUTDEF(name, long_name, ext, codec) |
1189 |
#elif CONFIG_MUXERS && CONFIG_DEMUXERS
|
1190 |
#define PCMDEF(name, long_name, ext, codec) \
|
1191 |
PCMINPUTDEF(name, long_name, ext, codec)\ |
1192 |
PCMOUTPUTDEF(name, long_name, ext, codec) |
1193 |
#else
|
1194 |
#define PCMDEF(name, long_name, ext, codec)
|
1195 |
#endif
|
1196 |
|
1197 |
#ifdef WORDS_BIGENDIAN
|
1198 |
#define BE_DEF(s) s
|
1199 |
#define LE_DEF(s) NULL |
1200 |
#else
|
1201 |
#define BE_DEF(s) NULL |
1202 |
#define LE_DEF(s) s
|
1203 |
#endif
|
1204 |
|
1205 |
PCMDEF(f64be, "PCM 64 bit floating-point big-endian format",
|
1206 |
NULL, CODEC_ID_PCM_F64BE)
|
1207 |
|
1208 |
PCMDEF(f64le, "PCM 64 bit floating-point little-endian format",
|
1209 |
NULL, CODEC_ID_PCM_F64LE)
|
1210 |
|
1211 |
PCMDEF(f32be, "PCM 32 bit floating-point big-endian format",
|
1212 |
NULL, CODEC_ID_PCM_F32BE)
|
1213 |
|
1214 |
PCMDEF(f32le, "PCM 32 bit floating-point little-endian format",
|
1215 |
NULL, CODEC_ID_PCM_F32LE)
|
1216 |
|
1217 |
PCMDEF(s32be, "PCM signed 32 bit big-endian format",
|
1218 |
NULL, CODEC_ID_PCM_S32BE)
|
1219 |
|
1220 |
PCMDEF(s32le, "PCM signed 32 bit little-endian format",
|
1221 |
NULL, CODEC_ID_PCM_S32LE)
|
1222 |
|
1223 |
PCMDEF(s24be, "PCM signed 24 bit big-endian format",
|
1224 |
NULL, CODEC_ID_PCM_S24BE)
|
1225 |
|
1226 |
PCMDEF(s24le, "PCM signed 24 bit little-endian format",
|
1227 |
NULL, CODEC_ID_PCM_S24LE)
|
1228 |
|
1229 |
PCMDEF(s16be, "PCM signed 16 bit big-endian format",
|
1230 |
BE_DEF("sw"), CODEC_ID_PCM_S16BE)
|
1231 |
|
1232 |
PCMDEF(s16le, "PCM signed 16 bit little-endian format",
|
1233 |
LE_DEF("sw"), CODEC_ID_PCM_S16LE)
|
1234 |
|
1235 |
PCMDEF(s8, "PCM signed 8 bit format",
|
1236 |
"sb", CODEC_ID_PCM_S8)
|
1237 |
|
1238 |
PCMDEF(u32be, "PCM unsigned 32 bit big-endian format",
|
1239 |
NULL, CODEC_ID_PCM_U32BE)
|
1240 |
|
1241 |
PCMDEF(u32le, "PCM unsigned 32 bit little-endian format",
|
1242 |
NULL, CODEC_ID_PCM_U32LE)
|
1243 |
|
1244 |
PCMDEF(u24be, "PCM unsigned 24 bit big-endian format",
|
1245 |
NULL, CODEC_ID_PCM_U24BE)
|
1246 |
|
1247 |
PCMDEF(u24le, "PCM unsigned 24 bit little-endian format",
|
1248 |
NULL, CODEC_ID_PCM_U24LE)
|
1249 |
|
1250 |
PCMDEF(u16be, "PCM unsigned 16 bit big-endian format",
|
1251 |
BE_DEF("uw"), CODEC_ID_PCM_U16BE)
|
1252 |
|
1253 |
PCMDEF(u16le, "PCM unsigned 16 bit little-endian format",
|
1254 |
LE_DEF("uw"), CODEC_ID_PCM_U16LE)
|
1255 |
|
1256 |
PCMDEF(u8, "PCM unsigned 8 bit format",
|
1257 |
"ub", CODEC_ID_PCM_U8)
|
1258 |
|
1259 |
PCMDEF(alaw, "PCM A-law format",
|
1260 |
"al", CODEC_ID_PCM_ALAW)
|
1261 |
|
1262 |
PCMDEF(mulaw, "PCM mu-law format",
|
1263 |
"ul", CODEC_ID_PCM_MULAW)
|