Libav
|
00001 /* 00002 * RAW muxer and demuxer 00003 * Copyright (c) 2001 Fabrice Bellard 00004 * Copyright (c) 2005 Alex Beregszaszi 00005 * 00006 * This file is part of FFmpeg. 00007 * 00008 * FFmpeg is free software; you can redistribute it and/or 00009 * modify it under the terms of the GNU Lesser General Public 00010 * License as published by the Free Software Foundation; either 00011 * version 2.1 of the License, or (at your option) any later version. 00012 * 00013 * FFmpeg is distributed in the hope that it will be useful, 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00016 * Lesser General Public License for more details. 00017 * 00018 * You should have received a copy of the GNU Lesser General Public 00019 * License along with FFmpeg; if not, write to the Free Software 00020 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00021 */ 00022 00023 #include "libavutil/crc.h" 00024 #include "libavcodec/ac3_parser.h" 00025 #include "libavcodec/get_bits.h" 00026 #include "libavcodec/bytestream.h" 00027 #include "avformat.h" 00028 #include "raw.h" 00029 #include "id3v2.h" 00030 #include "id3v1.h" 00031 00032 /* simple formats */ 00033 00034 #if CONFIG_ROQ_MUXER 00035 static int roq_write_header(struct AVFormatContext *s) 00036 { 00037 static const uint8_t header[] = { 00038 0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00 00039 }; 00040 00041 put_buffer(s->pb, header, 8); 00042 put_flush_packet(s->pb); 00043 00044 return 0; 00045 } 00046 #endif 00047 00048 #if CONFIG_NULL_MUXER 00049 static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt) 00050 { 00051 return 0; 00052 } 00053 #endif 00054 00055 #if CONFIG_MUXERS 00056 static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt) 00057 { 00058 put_buffer(s->pb, pkt->data, pkt->size); 00059 put_flush_packet(s->pb); 00060 return 0; 00061 } 00062 #endif 00063 00064 #if CONFIG_DEMUXERS 00065 /* raw input */ 00066 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap) 00067 { 00068 AVStream *st; 00069 enum CodecID id; 00070 00071 st = av_new_stream(s, 0); 00072 if (!st) 00073 return AVERROR(ENOMEM); 00074 00075 id = s->iformat->value; 00076 if (id == CODEC_ID_RAWVIDEO) { 00077 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; 00078 } else { 00079 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; 00080 } 00081 st->codec->codec_id = id; 00082 00083 switch(st->codec->codec_type) { 00084 case AVMEDIA_TYPE_AUDIO: 00085 st->codec->sample_rate = ap->sample_rate; 00086 if(ap->channels) st->codec->channels = ap->channels; 00087 else st->codec->channels = 1; 00088 st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id); 00089 assert(st->codec->bits_per_coded_sample > 0); 00090 st->codec->block_align = st->codec->bits_per_coded_sample*st->codec->channels/8; 00091 av_set_pts_info(st, 64, 1, st->codec->sample_rate); 00092 break; 00093 case AVMEDIA_TYPE_VIDEO: 00094 if(ap->time_base.num) 00095 av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den); 00096 else 00097 av_set_pts_info(st, 64, 1, 25); 00098 st->codec->width = ap->width; 00099 st->codec->height = ap->height; 00100 st->codec->pix_fmt = ap->pix_fmt; 00101 if(st->codec->pix_fmt == PIX_FMT_NONE) 00102 st->codec->pix_fmt= PIX_FMT_YUV420P; 00103 break; 00104 default: 00105 return -1; 00106 } 00107 return 0; 00108 } 00109 00110 #define RAW_PACKET_SIZE 1024 00111 #define RAW_SAMPLES 1024 00112 00113 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt) 00114 { 00115 int ret, size, bps; 00116 // AVStream *st = s->streams[0]; 00117 00118 size= RAW_SAMPLES*s->streams[0]->codec->block_align; 00119 00120 ret= av_get_packet(s->pb, pkt, size); 00121 00122 pkt->stream_index = 0; 00123 if (ret < 0) 00124 return ret; 00125 00126 bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id); 00127 assert(bps); // if false there IS a bug elsewhere (NOT in this function) 00128 pkt->dts= 00129 pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels); 00130 00131 return ret; 00132 } 00133 00134 int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt) 00135 { 00136 int ret, size; 00137 00138 size = RAW_PACKET_SIZE; 00139 00140 if (av_new_packet(pkt, size) < 0) 00141 return AVERROR(ENOMEM); 00142 00143 pkt->pos= url_ftell(s->pb); 00144 pkt->stream_index = 0; 00145 ret = get_partial_buffer(s->pb, pkt->data, size); 00146 if (ret < 0) { 00147 av_free_packet(pkt); 00148 return ret; 00149 } 00150 pkt->size = ret; 00151 return ret; 00152 } 00153 #endif 00154 00155 #if CONFIG_RAWVIDEO_DEMUXER 00156 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt) 00157 { 00158 int packet_size, ret, width, height; 00159 AVStream *st = s->streams[0]; 00160 00161 width = st->codec->width; 00162 height = st->codec->height; 00163 00164 packet_size = avpicture_get_size(st->codec->pix_fmt, width, height); 00165 if (packet_size < 0) 00166 return -1; 00167 00168 ret= av_get_packet(s->pb, pkt, packet_size); 00169 pkt->pts= 00170 pkt->dts= pkt->pos / packet_size; 00171 00172 pkt->stream_index = 0; 00173 if (ret < 0) 00174 return ret; 00175 return 0; 00176 } 00177 #endif 00178 00179 #if CONFIG_INGENIENT_DEMUXER 00180 // http://www.artificis.hu/files/texts/ingenient.txt 00181 static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt) 00182 { 00183 int ret, size, w, h, unk1, unk2; 00184 00185 if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G')) 00186 return AVERROR(EIO); // FIXME 00187 00188 size = get_le32(s->pb); 00189 00190 w = get_le16(s->pb); 00191 h = get_le16(s->pb); 00192 00193 url_fskip(s->pb, 8); // zero + size (padded?) 00194 url_fskip(s->pb, 2); 00195 unk1 = get_le16(s->pb); 00196 unk2 = get_le16(s->pb); 00197 url_fskip(s->pb, 22); // ASCII timestamp 00198 00199 av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n", 00200 size, w, h, unk1, unk2); 00201 00202 if (av_new_packet(pkt, size) < 0) 00203 return AVERROR(ENOMEM); 00204 00205 pkt->pos = url_ftell(s->pb); 00206 pkt->stream_index = 0; 00207 ret = get_buffer(s->pb, pkt->data, size); 00208 if (ret < 0) { 00209 av_free_packet(pkt); 00210 return ret; 00211 } 00212 pkt->size = ret; 00213 return ret; 00214 } 00215 #endif 00216 00217 #if CONFIG_DEMUXERS 00218 int pcm_read_seek(AVFormatContext *s, 00219 int stream_index, int64_t timestamp, int flags) 00220 { 00221 AVStream *st; 00222 int block_align, byte_rate; 00223 int64_t pos, ret; 00224 00225 st = s->streams[0]; 00226 00227 block_align = st->codec->block_align ? st->codec->block_align : 00228 (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3; 00229 byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 : 00230 block_align * st->codec->sample_rate; 00231 00232 if (block_align <= 0 || byte_rate <= 0) 00233 return -1; 00234 if (timestamp < 0) timestamp = 0; 00235 00236 /* compute the position by aligning it to block_align */ 00237 pos = av_rescale_rnd(timestamp * byte_rate, 00238 st->time_base.num, 00239 st->time_base.den * (int64_t)block_align, 00240 (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP); 00241 pos *= block_align; 00242 00243 /* recompute exact position */ 00244 st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num); 00245 if ((ret = url_fseek(s->pb, pos + s->data_offset, SEEK_SET)) < 0) 00246 return ret; 00247 return 0; 00248 } 00249 00250 static int audio_read_header(AVFormatContext *s, 00251 AVFormatParameters *ap) 00252 { 00253 AVStream *st = av_new_stream(s, 0); 00254 if (!st) 00255 return AVERROR(ENOMEM); 00256 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; 00257 st->codec->codec_id = s->iformat->value; 00258 st->need_parsing = AVSTREAM_PARSE_FULL; 00259 /* the parameters will be extracted from the compressed bitstream */ 00260 00261 return 0; 00262 } 00263 00264 /* MPEG-1/H.263 input */ 00265 static int video_read_header(AVFormatContext *s, 00266 AVFormatParameters *ap) 00267 { 00268 AVStream *st; 00269 00270 st = av_new_stream(s, 0); 00271 if (!st) 00272 return AVERROR(ENOMEM); 00273 00274 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; 00275 st->codec->codec_id = s->iformat->value; 00276 st->need_parsing = AVSTREAM_PARSE_FULL; 00277 00278 /* for MJPEG, specify frame rate */ 00279 /* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop_rate set ...)*/ 00280 if (ap->time_base.num) { 00281 st->codec->time_base= ap->time_base; 00282 } else if ( st->codec->codec_id == CODEC_ID_MJPEG || 00283 st->codec->codec_id == CODEC_ID_MPEG4 || 00284 st->codec->codec_id == CODEC_ID_DIRAC || 00285 st->codec->codec_id == CODEC_ID_DNXHD || 00286 st->codec->codec_id == CODEC_ID_H264) { 00287 st->codec->time_base= (AVRational){1,25}; 00288 } 00289 av_set_pts_info(st, 64, 1, 1200000); 00290 00291 return 0; 00292 } 00293 #endif 00294 00295 #if CONFIG_MPEGVIDEO_DEMUXER 00296 #define SEQ_START_CODE 0x000001b3 00297 #define GOP_START_CODE 0x000001b8 00298 #define PICTURE_START_CODE 0x00000100 00299 #define SLICE_START_CODE 0x00000101 00300 #define PACK_START_CODE 0x000001ba 00301 #define VIDEO_ID 0x000001e0 00302 #define AUDIO_ID 0x000001c0 00303 00304 static int mpegvideo_probe(AVProbeData *p) 00305 { 00306 uint32_t code= -1; 00307 int pic=0, seq=0, slice=0, pspack=0, pes=0; 00308 int i; 00309 00310 for(i=0; i<p->buf_size; i++){ 00311 code = (code<<8) + p->buf[i]; 00312 if ((code & 0xffffff00) == 0x100) { 00313 switch(code){ 00314 case SEQ_START_CODE: seq++; break; 00315 case PICTURE_START_CODE: pic++; break; 00316 case SLICE_START_CODE: slice++; break; 00317 case PACK_START_CODE: pspack++; break; 00318 } 00319 if ((code & 0x1f0) == VIDEO_ID) pes++; 00320 else if((code & 0x1e0) == AUDIO_ID) pes++; 00321 } 00322 } 00323 if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes) 00324 return pic>1 ? AVPROBE_SCORE_MAX/2+1 : AVPROBE_SCORE_MAX/4; // +1 for .mpg 00325 return 0; 00326 } 00327 #endif 00328 00329 #if CONFIG_CAVSVIDEO_DEMUXER 00330 #define CAVS_SEQ_START_CODE 0x000001b0 00331 #define CAVS_PIC_I_START_CODE 0x000001b3 00332 #define CAVS_UNDEF_START_CODE 0x000001b4 00333 #define CAVS_PIC_PB_START_CODE 0x000001b6 00334 #define CAVS_VIDEO_EDIT_CODE 0x000001b7 00335 #define CAVS_PROFILE_JIZHUN 0x20 00336 00337 static int cavsvideo_probe(AVProbeData *p) 00338 { 00339 uint32_t code= -1; 00340 int pic=0, seq=0, slice_pos = 0; 00341 int i; 00342 00343 for(i=0; i<p->buf_size; i++){ 00344 code = (code<<8) + p->buf[i]; 00345 if ((code & 0xffffff00) == 0x100) { 00346 if(code < CAVS_SEQ_START_CODE) { 00347 /* slices have to be consecutive */ 00348 if(code < slice_pos) 00349 return 0; 00350 slice_pos = code; 00351 } else { 00352 slice_pos = 0; 00353 } 00354 if (code == CAVS_SEQ_START_CODE) { 00355 seq++; 00356 /* check for the only currently supported profile */ 00357 if(p->buf[i+1] != CAVS_PROFILE_JIZHUN) 00358 return 0; 00359 } else if ((code == CAVS_PIC_I_START_CODE) || 00360 (code == CAVS_PIC_PB_START_CODE)) { 00361 pic++; 00362 } else if ((code == CAVS_UNDEF_START_CODE) || 00363 (code > CAVS_VIDEO_EDIT_CODE)) { 00364 return 0; 00365 } 00366 } 00367 } 00368 if(seq && seq*9<=pic*10) 00369 return AVPROBE_SCORE_MAX/2; 00370 return 0; 00371 } 00372 #endif 00373 00374 #if CONFIG_M4V_DEMUXER 00375 #define VISUAL_OBJECT_START_CODE 0x000001b5 00376 #define VOP_START_CODE 0x000001b6 00377 00378 static int mpeg4video_probe(AVProbeData *probe_packet) 00379 { 00380 uint32_t temp_buffer= -1; 00381 int VO=0, VOL=0, VOP = 0, VISO = 0, res=0; 00382 int i; 00383 00384 for(i=0; i<probe_packet->buf_size; i++){ 00385 temp_buffer = (temp_buffer<<8) + probe_packet->buf[i]; 00386 if ((temp_buffer & 0xffffff00) != 0x100) 00387 continue; 00388 00389 if (temp_buffer == VOP_START_CODE) VOP++; 00390 else if (temp_buffer == VISUAL_OBJECT_START_CODE) VISO++; 00391 else if (temp_buffer < 0x120) VO++; 00392 else if (temp_buffer < 0x130) VOL++; 00393 else if ( !(0x1AF < temp_buffer && temp_buffer < 0x1B7) 00394 && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++; 00395 } 00396 00397 if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0) 00398 return AVPROBE_SCORE_MAX/2; 00399 return 0; 00400 } 00401 #endif 00402 00403 #if CONFIG_H264_DEMUXER 00404 static int h264_probe(AVProbeData *p) 00405 { 00406 uint32_t code= -1; 00407 int sps=0, pps=0, idr=0, res=0, sli=0; 00408 int i; 00409 00410 for(i=0; i<p->buf_size; i++){ 00411 code = (code<<8) + p->buf[i]; 00412 if ((code & 0xffffff00) == 0x100) { 00413 int ref_idc= (code>>5)&3; 00414 int type = code & 0x1F; 00415 static const int8_t ref_zero[32]={ 00416 2, 0, 0, 0, 0,-1, 1,-1, 00417 -1, 1, 1, 1, 1,-1, 2, 2, 00418 2, 2, 2, 0, 2, 2, 2, 2, 00419 2, 2, 2, 2, 2, 2, 2, 2 00420 }; 00421 00422 if(code & 0x80) //forbidden bit 00423 return 0; 00424 00425 if(ref_zero[type] == 1 && ref_idc) 00426 return 0; 00427 if(ref_zero[type] ==-1 && !ref_idc) 00428 return 0; 00429 if(ref_zero[type] == 2) 00430 res++; 00431 00432 switch(type){ 00433 case 1: sli++; break; 00434 case 5: idr++; break; 00435 case 7: 00436 if(p->buf[i+2]&0x0F) 00437 return 0; 00438 sps++; 00439 break; 00440 case 8: pps++; break; 00441 } 00442 } 00443 } 00444 if(sps && pps && (idr||sli>3) && res<(sps+pps+idr)) 00445 return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg 00446 return 0; 00447 } 00448 #endif 00449 00450 #if CONFIG_H263_DEMUXER 00451 static int h263_probe(AVProbeData *p) 00452 { 00453 uint64_t code= -1; 00454 int i; 00455 int valid_psc=0; 00456 int invalid_psc=0; 00457 int res_change=0; 00458 int src_fmt, last_src_fmt=-1; 00459 00460 for(i=0; i<p->buf_size; i++){ 00461 code = (code<<8) + p->buf[i]; 00462 if ((code & 0xfffffc0000) == 0x800000) { 00463 src_fmt= (code>>2)&3; 00464 if( src_fmt != last_src_fmt 00465 && last_src_fmt>0 && last_src_fmt<6 00466 && src_fmt<6) 00467 res_change++; 00468 00469 if((code&0x300)==0x200 && src_fmt){ 00470 valid_psc++; 00471 }else 00472 invalid_psc++; 00473 last_src_fmt= src_fmt; 00474 } 00475 } 00476 //av_log(NULL, AV_LOG_ERROR, "h263_probe: psc:%d invalid:%d res_change:%d\n", valid_psc, invalid_psc, res_change); 00477 //h263_probe: psc:3 invalid:0 res_change:0 (1588/recent_ffmpeg_parses_mpg_incorrectly.mpg) 00478 if(valid_psc > 2*invalid_psc + 2*res_change + 3){ 00479 return 50; 00480 }else if(valid_psc > 2*invalid_psc) 00481 return 25; 00482 return 0; 00483 } 00484 #endif 00485 00486 #if CONFIG_H261_DEMUXER 00487 static int h261_probe(AVProbeData *p) 00488 { 00489 uint32_t code= -1; 00490 int i; 00491 int valid_psc=0; 00492 int invalid_psc=0; 00493 int next_gn=0; 00494 int src_fmt=0; 00495 GetBitContext gb; 00496 00497 init_get_bits(&gb, p->buf, p->buf_size*8); 00498 00499 for(i=0; i<p->buf_size*8; i++){ 00500 if ((code & 0x01ff0000) || !(code & 0xff00)) { 00501 code = (code<<8) + get_bits(&gb, 8); 00502 i += 7; 00503 } else 00504 code = (code<<1) + get_bits1(&gb); 00505 if ((code & 0xffff0000) == 0x10000) { 00506 int gn= (code>>12)&0xf; 00507 if(!gn) 00508 src_fmt= code&8; 00509 if(gn != next_gn) invalid_psc++; 00510 else valid_psc++; 00511 00512 if(src_fmt){ // CIF 00513 next_gn= (gn+1 )%13; 00514 }else{ //QCIF 00515 next_gn= (gn+1+!!gn)% 7; 00516 } 00517 } 00518 } 00519 if(valid_psc > 2*invalid_psc + 6){ 00520 return 50; 00521 }else if(valid_psc > 2*invalid_psc + 2) 00522 return 25; 00523 return 0; 00524 } 00525 #endif 00526 00527 #if CONFIG_DTS_DEMUXER 00528 #define DCA_MARKER_14B_BE 0x1FFFE800 00529 #define DCA_MARKER_14B_LE 0xFF1F00E8 00530 #define DCA_MARKER_RAW_BE 0x7FFE8001 00531 #define DCA_MARKER_RAW_LE 0xFE7F0180 00532 static int dts_probe(AVProbeData *p) 00533 { 00534 const uint8_t *buf, *bufp; 00535 uint32_t state = -1; 00536 int markers[3] = {0}; 00537 int sum, max; 00538 00539 buf = p->buf; 00540 00541 for(; buf < (p->buf+p->buf_size)-2; buf+=2) { 00542 bufp = buf; 00543 state = (state << 16) | bytestream_get_be16(&bufp); 00544 00545 /* regular bitstream */ 00546 if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE) 00547 markers[0]++; 00548 00549 /* 14 bits big-endian bitstream */ 00550 if (state == DCA_MARKER_14B_BE) 00551 if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0) 00552 markers[1]++; 00553 00554 /* 14 bits little-endian bitstream */ 00555 if (state == DCA_MARKER_14B_LE) 00556 if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007) 00557 markers[2]++; 00558 } 00559 sum = markers[0] + markers[1] + markers[2]; 00560 max = markers[1] > markers[0]; 00561 max = markers[2] > markers[max] ? 2 : max; 00562 if (markers[max] > 3 && p->buf_size / markers[max] < 32*1024 && 00563 markers[max] * 4 > sum * 3) 00564 return AVPROBE_SCORE_MAX/2+1; 00565 00566 return 0; 00567 } 00568 #endif 00569 00570 #if CONFIG_DIRAC_DEMUXER 00571 static int dirac_probe(AVProbeData *p) 00572 { 00573 if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D')) 00574 return AVPROBE_SCORE_MAX; 00575 else 00576 return 0; 00577 } 00578 #endif 00579 00580 #if CONFIG_DNXHD_DEMUXER 00581 static int dnxhd_probe(AVProbeData *p) 00582 { 00583 static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01}; 00584 int w, h, compression_id; 00585 if (p->buf_size < 0x2c) 00586 return 0; 00587 if (memcmp(p->buf, header, 5)) 00588 return 0; 00589 h = AV_RB16(p->buf + 0x18); 00590 w = AV_RB16(p->buf + 0x1a); 00591 if (!w || !h) 00592 return 0; 00593 compression_id = AV_RB32(p->buf + 0x28); 00594 if (compression_id < 1237 || compression_id > 1253) 00595 return 0; 00596 return AVPROBE_SCORE_MAX; 00597 } 00598 #endif 00599 00600 #if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER 00601 static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id) 00602 { 00603 int max_frames, first_frames = 0, frames; 00604 uint8_t *buf, *buf2, *end; 00605 AC3HeaderInfo hdr; 00606 GetBitContext gbc; 00607 enum CodecID codec_id = CODEC_ID_AC3; 00608 00609 max_frames = 0; 00610 buf = p->buf; 00611 end = buf + p->buf_size; 00612 00613 for(; buf < end; buf++) { 00614 buf2 = buf; 00615 00616 for(frames = 0; buf2 < end; frames++) { 00617 init_get_bits(&gbc, buf2, 54); 00618 if(ff_ac3_parse_header(&gbc, &hdr) < 0) 00619 break; 00620 if(buf2 + hdr.frame_size > end || 00621 av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2)) 00622 break; 00623 if (hdr.bitstream_id > 10) 00624 codec_id = CODEC_ID_EAC3; 00625 buf2 += hdr.frame_size; 00626 } 00627 max_frames = FFMAX(max_frames, frames); 00628 if(buf == p->buf) 00629 first_frames = frames; 00630 } 00631 if(codec_id != expected_codec_id) return 0; 00632 // keep this in sync with mp3 probe, both need to avoid 00633 // issues with MPEG-files! 00634 if (first_frames>=4) return AVPROBE_SCORE_MAX/2+1; 00635 else if(max_frames>500)return AVPROBE_SCORE_MAX/2; 00636 else if(max_frames>=4) return AVPROBE_SCORE_MAX/4; 00637 else if(max_frames>=1) return 1; 00638 else return 0; 00639 } 00640 #endif 00641 00642 #if CONFIG_AC3_DEMUXER 00643 static int ac3_probe(AVProbeData *p) 00644 { 00645 return ac3_eac3_probe(p, CODEC_ID_AC3); 00646 } 00647 #endif 00648 00649 #if CONFIG_EAC3_DEMUXER 00650 static int eac3_probe(AVProbeData *p) 00651 { 00652 return ac3_eac3_probe(p, CODEC_ID_EAC3); 00653 } 00654 #endif 00655 00656 #if CONFIG_AAC_DEMUXER 00657 static int adts_aac_probe(AVProbeData *p) 00658 { 00659 int max_frames = 0, first_frames = 0; 00660 int fsize, frames; 00661 uint8_t *buf0 = p->buf; 00662 uint8_t *buf2; 00663 uint8_t *buf; 00664 uint8_t *end = buf0 + p->buf_size - 7; 00665 00666 if (ff_id3v2_match(buf0)) { 00667 buf0 += ff_id3v2_tag_len(buf0); 00668 } 00669 buf = buf0; 00670 00671 for(; buf < end; buf= buf2+1) { 00672 buf2 = buf; 00673 00674 for(frames = 0; buf2 < end; frames++) { 00675 uint32_t header = AV_RB16(buf2); 00676 if((header&0xFFF6) != 0xFFF0) 00677 break; 00678 fsize = (AV_RB32(buf2+3)>>13) & 0x8FFF; 00679 if(fsize < 7) 00680 break; 00681 buf2 += fsize; 00682 } 00683 max_frames = FFMAX(max_frames, frames); 00684 if(buf == buf0) 00685 first_frames= frames; 00686 } 00687 if (first_frames>=3) return AVPROBE_SCORE_MAX/2+1; 00688 else if(max_frames>500)return AVPROBE_SCORE_MAX/2; 00689 else if(max_frames>=3) return AVPROBE_SCORE_MAX/4; 00690 else if(max_frames>=1) return 1; 00691 else return 0; 00692 } 00693 00694 static int adts_aac_read_header(AVFormatContext *s, 00695 AVFormatParameters *ap) 00696 { 00697 AVStream *st; 00698 00699 st = av_new_stream(s, 0); 00700 if (!st) 00701 return AVERROR(ENOMEM); 00702 00703 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; 00704 st->codec->codec_id = s->iformat->value; 00705 st->need_parsing = AVSTREAM_PARSE_FULL; 00706 00707 ff_id3v1_read(s); 00708 ff_id3v2_read(s); 00709 00710 return 0; 00711 } 00712 00713 #endif 00714 00715 /* Note: Do not forget to add new entries to the Makefile as well. */ 00716 00717 #if CONFIG_AAC_DEMUXER 00718 AVInputFormat aac_demuxer = { 00719 "aac", 00720 NULL_IF_CONFIG_SMALL("raw ADTS AAC"), 00721 0, 00722 adts_aac_probe, 00723 adts_aac_read_header, 00724 ff_raw_read_partial_packet, 00725 .flags= AVFMT_GENERIC_INDEX, 00726 .extensions = "aac", 00727 .value = CODEC_ID_AAC, 00728 }; 00729 #endif 00730 00731 #if CONFIG_AC3_DEMUXER 00732 AVInputFormat ac3_demuxer = { 00733 "ac3", 00734 NULL_IF_CONFIG_SMALL("raw AC-3"), 00735 0, 00736 ac3_probe, 00737 audio_read_header, 00738 ff_raw_read_partial_packet, 00739 .flags= AVFMT_GENERIC_INDEX, 00740 .extensions = "ac3", 00741 .value = CODEC_ID_AC3, 00742 }; 00743 #endif 00744 00745 #if CONFIG_AC3_MUXER 00746 AVOutputFormat ac3_muxer = { 00747 "ac3", 00748 NULL_IF_CONFIG_SMALL("raw AC-3"), 00749 "audio/x-ac3", 00750 "ac3", 00751 0, 00752 CODEC_ID_AC3, 00753 CODEC_ID_NONE, 00754 NULL, 00755 raw_write_packet, 00756 .flags= AVFMT_NOTIMESTAMPS, 00757 }; 00758 #endif 00759 00760 #if CONFIG_DIRAC_DEMUXER 00761 AVInputFormat dirac_demuxer = { 00762 "dirac", 00763 NULL_IF_CONFIG_SMALL("raw Dirac"), 00764 0, 00765 dirac_probe, 00766 video_read_header, 00767 ff_raw_read_partial_packet, 00768 .flags= AVFMT_GENERIC_INDEX, 00769 .value = CODEC_ID_DIRAC, 00770 }; 00771 #endif 00772 00773 #if CONFIG_DIRAC_MUXER 00774 AVOutputFormat dirac_muxer = { 00775 "dirac", 00776 NULL_IF_CONFIG_SMALL("raw Dirac"), 00777 NULL, 00778 "drc", 00779 0, 00780 CODEC_ID_NONE, 00781 CODEC_ID_DIRAC, 00782 NULL, 00783 raw_write_packet, 00784 .flags= AVFMT_NOTIMESTAMPS, 00785 }; 00786 #endif 00787 00788 #if CONFIG_DNXHD_DEMUXER 00789 AVInputFormat dnxhd_demuxer = { 00790 "dnxhd", 00791 NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"), 00792 0, 00793 dnxhd_probe, 00794 video_read_header, 00795 ff_raw_read_partial_packet, 00796 .flags= AVFMT_GENERIC_INDEX, 00797 .value = CODEC_ID_DNXHD, 00798 }; 00799 #endif 00800 00801 #if CONFIG_DNXHD_MUXER 00802 AVOutputFormat dnxhd_muxer = { 00803 "dnxhd", 00804 NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"), 00805 NULL, 00806 "dnxhd", 00807 0, 00808 CODEC_ID_NONE, 00809 CODEC_ID_DNXHD, 00810 NULL, 00811 raw_write_packet, 00812 .flags= AVFMT_NOTIMESTAMPS, 00813 }; 00814 #endif 00815 00816 #if CONFIG_DTS_DEMUXER 00817 AVInputFormat dts_demuxer = { 00818 "dts", 00819 NULL_IF_CONFIG_SMALL("raw DTS"), 00820 0, 00821 dts_probe, 00822 audio_read_header, 00823 ff_raw_read_partial_packet, 00824 .flags= AVFMT_GENERIC_INDEX, 00825 .extensions = "dts", 00826 .value = CODEC_ID_DTS, 00827 }; 00828 #endif 00829 00830 #if CONFIG_DTS_MUXER 00831 AVOutputFormat dts_muxer = { 00832 "dts", 00833 NULL_IF_CONFIG_SMALL("raw DTS"), 00834 "audio/x-dca", 00835 "dts", 00836 0, 00837 CODEC_ID_DTS, 00838 CODEC_ID_NONE, 00839 NULL, 00840 raw_write_packet, 00841 .flags= AVFMT_NOTIMESTAMPS, 00842 }; 00843 #endif 00844 00845 #if CONFIG_EAC3_DEMUXER 00846 AVInputFormat eac3_demuxer = { 00847 "eac3", 00848 NULL_IF_CONFIG_SMALL("raw E-AC-3"), 00849 0, 00850 eac3_probe, 00851 audio_read_header, 00852 ff_raw_read_partial_packet, 00853 .flags= AVFMT_GENERIC_INDEX, 00854 .extensions = "eac3", 00855 .value = CODEC_ID_EAC3, 00856 }; 00857 #endif 00858 00859 #if CONFIG_EAC3_MUXER 00860 AVOutputFormat eac3_muxer = { 00861 "eac3", 00862 NULL_IF_CONFIG_SMALL("raw E-AC-3"), 00863 "audio/x-eac3", 00864 "eac3", 00865 0, 00866 CODEC_ID_EAC3, 00867 CODEC_ID_NONE, 00868 NULL, 00869 raw_write_packet, 00870 .flags= AVFMT_NOTIMESTAMPS, 00871 }; 00872 #endif 00873 00874 #if CONFIG_GSM_DEMUXER 00875 AVInputFormat gsm_demuxer = { 00876 "gsm", 00877 NULL_IF_CONFIG_SMALL("raw GSM"), 00878 0, 00879 NULL, 00880 audio_read_header, 00881 ff_raw_read_partial_packet, 00882 .flags= AVFMT_GENERIC_INDEX, 00883 .extensions = "gsm", 00884 .value = CODEC_ID_GSM, 00885 }; 00886 #endif 00887 00888 #if CONFIG_H261_DEMUXER 00889 AVInputFormat h261_demuxer = { 00890 "h261", 00891 NULL_IF_CONFIG_SMALL("raw H.261"), 00892 0, 00893 h261_probe, 00894 video_read_header, 00895 ff_raw_read_partial_packet, 00896 .flags= AVFMT_GENERIC_INDEX, 00897 .extensions = "h261", 00898 .value = CODEC_ID_H261, 00899 }; 00900 #endif 00901 00902 #if CONFIG_H261_MUXER 00903 AVOutputFormat h261_muxer = { 00904 "h261", 00905 NULL_IF_CONFIG_SMALL("raw H.261"), 00906 "video/x-h261", 00907 "h261", 00908 0, 00909 CODEC_ID_NONE, 00910 CODEC_ID_H261, 00911 NULL, 00912 raw_write_packet, 00913 .flags= AVFMT_NOTIMESTAMPS, 00914 }; 00915 #endif 00916 00917 #if CONFIG_H263_DEMUXER 00918 AVInputFormat h263_demuxer = { 00919 "h263", 00920 NULL_IF_CONFIG_SMALL("raw H.263"), 00921 0, 00922 h263_probe, 00923 video_read_header, 00924 ff_raw_read_partial_packet, 00925 .flags= AVFMT_GENERIC_INDEX, 00926 // .extensions = "h263", //FIXME remove after writing mpeg4_probe 00927 .value = CODEC_ID_H263, 00928 }; 00929 #endif 00930 00931 #if CONFIG_H263_MUXER 00932 AVOutputFormat h263_muxer = { 00933 "h263", 00934 NULL_IF_CONFIG_SMALL("raw H.263"), 00935 "video/x-h263", 00936 "h263", 00937 0, 00938 CODEC_ID_NONE, 00939 CODEC_ID_H263, 00940 NULL, 00941 raw_write_packet, 00942 .flags= AVFMT_NOTIMESTAMPS, 00943 }; 00944 #endif 00945 00946 #if CONFIG_H264_DEMUXER 00947 AVInputFormat h264_demuxer = { 00948 "h264", 00949 NULL_IF_CONFIG_SMALL("raw H.264 video format"), 00950 0, 00951 h264_probe, 00952 video_read_header, 00953 ff_raw_read_partial_packet, 00954 .flags= AVFMT_GENERIC_INDEX, 00955 .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe 00956 .value = CODEC_ID_H264, 00957 }; 00958 #endif 00959 00960 #if CONFIG_H264_MUXER 00961 AVOutputFormat h264_muxer = { 00962 "h264", 00963 NULL_IF_CONFIG_SMALL("raw H.264 video format"), 00964 NULL, 00965 "h264", 00966 0, 00967 CODEC_ID_NONE, 00968 CODEC_ID_H264, 00969 NULL, 00970 raw_write_packet, 00971 .flags= AVFMT_NOTIMESTAMPS, 00972 }; 00973 #endif 00974 00975 #if CONFIG_INGENIENT_DEMUXER 00976 AVInputFormat ingenient_demuxer = { 00977 "ingenient", 00978 NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"), 00979 0, 00980 NULL, 00981 video_read_header, 00982 ingenient_read_packet, 00983 .flags= AVFMT_GENERIC_INDEX, 00984 .extensions = "cgi", // FIXME 00985 .value = CODEC_ID_MJPEG, 00986 }; 00987 #endif 00988 00989 #if CONFIG_M4V_DEMUXER 00990 AVInputFormat m4v_demuxer = { 00991 "m4v", 00992 NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"), 00993 0, 00994 mpeg4video_probe, 00995 video_read_header, 00996 ff_raw_read_partial_packet, 00997 .flags= AVFMT_GENERIC_INDEX, 00998 .extensions = "m4v", 00999 .value = CODEC_ID_MPEG4, 01000 }; 01001 #endif 01002 01003 #if CONFIG_M4V_MUXER 01004 AVOutputFormat m4v_muxer = { 01005 "m4v", 01006 NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"), 01007 NULL, 01008 "m4v", 01009 0, 01010 CODEC_ID_NONE, 01011 CODEC_ID_MPEG4, 01012 NULL, 01013 raw_write_packet, 01014 .flags= AVFMT_NOTIMESTAMPS, 01015 }; 01016 #endif 01017 01018 #if CONFIG_MJPEG_DEMUXER 01019 AVInputFormat mjpeg_demuxer = { 01020 "mjpeg", 01021 NULL_IF_CONFIG_SMALL("raw MJPEG video"), 01022 0, 01023 NULL, 01024 video_read_header, 01025 ff_raw_read_partial_packet, 01026 .flags= AVFMT_GENERIC_INDEX, 01027 .extensions = "mjpg,mjpeg", 01028 .value = CODEC_ID_MJPEG, 01029 }; 01030 #endif 01031 01032 #if CONFIG_MJPEG_MUXER 01033 AVOutputFormat mjpeg_muxer = { 01034 "mjpeg", 01035 NULL_IF_CONFIG_SMALL("raw MJPEG video"), 01036 "video/x-mjpeg", 01037 "mjpg,mjpeg", 01038 0, 01039 CODEC_ID_NONE, 01040 CODEC_ID_MJPEG, 01041 NULL, 01042 raw_write_packet, 01043 .flags= AVFMT_NOTIMESTAMPS, 01044 }; 01045 #endif 01046 01047 #if CONFIG_MLP_DEMUXER 01048 AVInputFormat mlp_demuxer = { 01049 "mlp", 01050 NULL_IF_CONFIG_SMALL("raw MLP"), 01051 0, 01052 NULL, 01053 audio_read_header, 01054 ff_raw_read_partial_packet, 01055 .flags= AVFMT_GENERIC_INDEX, 01056 .extensions = "mlp", 01057 .value = CODEC_ID_MLP, 01058 }; 01059 #endif 01060 01061 #if CONFIG_MLP_MUXER 01062 AVOutputFormat mlp_muxer = { 01063 "mlp", 01064 NULL_IF_CONFIG_SMALL("raw MLP"), 01065 NULL, 01066 "mlp", 01067 0, 01068 CODEC_ID_MLP, 01069 CODEC_ID_NONE, 01070 NULL, 01071 raw_write_packet, 01072 .flags= AVFMT_NOTIMESTAMPS, 01073 }; 01074 #endif 01075 01076 #if CONFIG_TRUEHD_DEMUXER 01077 AVInputFormat truehd_demuxer = { 01078 "truehd", 01079 NULL_IF_CONFIG_SMALL("raw TrueHD"), 01080 0, 01081 NULL, 01082 audio_read_header, 01083 ff_raw_read_partial_packet, 01084 .flags= AVFMT_GENERIC_INDEX, 01085 .extensions = "thd", 01086 .value = CODEC_ID_TRUEHD, 01087 }; 01088 #endif 01089 01090 #if CONFIG_TRUEHD_MUXER 01091 AVOutputFormat truehd_muxer = { 01092 "truehd", 01093 NULL_IF_CONFIG_SMALL("raw TrueHD"), 01094 NULL, 01095 "thd", 01096 0, 01097 CODEC_ID_TRUEHD, 01098 CODEC_ID_NONE, 01099 NULL, 01100 raw_write_packet, 01101 .flags= AVFMT_NOTIMESTAMPS, 01102 }; 01103 #endif 01104 01105 #if CONFIG_MPEG1VIDEO_MUXER 01106 AVOutputFormat mpeg1video_muxer = { 01107 "mpeg1video", 01108 NULL_IF_CONFIG_SMALL("raw MPEG-1 video"), 01109 "video/x-mpeg", 01110 "mpg,mpeg,m1v", 01111 0, 01112 CODEC_ID_NONE, 01113 CODEC_ID_MPEG1VIDEO, 01114 NULL, 01115 raw_write_packet, 01116 .flags= AVFMT_NOTIMESTAMPS, 01117 }; 01118 #endif 01119 01120 #if CONFIG_MPEG2VIDEO_MUXER 01121 AVOutputFormat mpeg2video_muxer = { 01122 "mpeg2video", 01123 NULL_IF_CONFIG_SMALL("raw MPEG-2 video"), 01124 NULL, 01125 "m2v", 01126 0, 01127 CODEC_ID_NONE, 01128 CODEC_ID_MPEG2VIDEO, 01129 NULL, 01130 raw_write_packet, 01131 .flags= AVFMT_NOTIMESTAMPS, 01132 }; 01133 #endif 01134 01135 #if CONFIG_MPEGVIDEO_DEMUXER 01136 AVInputFormat mpegvideo_demuxer = { 01137 "mpegvideo", 01138 NULL_IF_CONFIG_SMALL("raw MPEG video"), 01139 0, 01140 mpegvideo_probe, 01141 video_read_header, 01142 ff_raw_read_partial_packet, 01143 .flags= AVFMT_GENERIC_INDEX, 01144 .value = CODEC_ID_MPEG1VIDEO, 01145 }; 01146 #endif 01147 01148 #if CONFIG_CAVSVIDEO_DEMUXER 01149 AVInputFormat cavsvideo_demuxer = { 01150 "cavsvideo", 01151 NULL_IF_CONFIG_SMALL("raw Chinese AVS video"), 01152 0, 01153 cavsvideo_probe, 01154 video_read_header, 01155 ff_raw_read_partial_packet, 01156 .flags= AVFMT_GENERIC_INDEX, 01157 .value = CODEC_ID_CAVS, 01158 }; 01159 #endif 01160 01161 #if CONFIG_NULL_MUXER 01162 AVOutputFormat null_muxer = { 01163 "null", 01164 NULL_IF_CONFIG_SMALL("raw null video format"), 01165 NULL, 01166 NULL, 01167 0, 01168 #if HAVE_BIGENDIAN 01169 CODEC_ID_PCM_S16BE, 01170 #else 01171 CODEC_ID_PCM_S16LE, 01172 #endif 01173 CODEC_ID_RAWVIDEO, 01174 NULL, 01175 null_write_packet, 01176 .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS, 01177 }; 01178 #endif 01179 01180 #if CONFIG_RAWVIDEO_DEMUXER 01181 AVInputFormat rawvideo_demuxer = { 01182 "rawvideo", 01183 NULL_IF_CONFIG_SMALL("raw video format"), 01184 0, 01185 NULL, 01186 raw_read_header, 01187 rawvideo_read_packet, 01188 .flags= AVFMT_GENERIC_INDEX, 01189 .extensions = "yuv,cif,qcif,rgb", 01190 .value = CODEC_ID_RAWVIDEO, 01191 }; 01192 #endif 01193 01194 #if CONFIG_RAWVIDEO_MUXER 01195 AVOutputFormat rawvideo_muxer = { 01196 "rawvideo", 01197 NULL_IF_CONFIG_SMALL("raw video format"), 01198 NULL, 01199 "yuv,rgb", 01200 0, 01201 CODEC_ID_NONE, 01202 CODEC_ID_RAWVIDEO, 01203 NULL, 01204 raw_write_packet, 01205 .flags= AVFMT_NOTIMESTAMPS, 01206 }; 01207 #endif 01208 01209 #if CONFIG_ROQ_MUXER 01210 AVOutputFormat roq_muxer = 01211 { 01212 "RoQ", 01213 NULL_IF_CONFIG_SMALL("raw id RoQ format"), 01214 NULL, 01215 "roq", 01216 0, 01217 CODEC_ID_ROQ_DPCM, 01218 CODEC_ID_ROQ, 01219 roq_write_header, 01220 raw_write_packet, 01221 }; 01222 #endif 01223 01224 #if CONFIG_SHORTEN_DEMUXER 01225 AVInputFormat shorten_demuxer = { 01226 "shn", 01227 NULL_IF_CONFIG_SMALL("raw Shorten"), 01228 0, 01229 NULL, 01230 audio_read_header, 01231 ff_raw_read_partial_packet, 01232 .flags= AVFMT_GENERIC_INDEX, 01233 .extensions = "shn", 01234 .value = CODEC_ID_SHORTEN, 01235 }; 01236 #endif 01237 01238 #if CONFIG_VC1_DEMUXER 01239 AVInputFormat vc1_demuxer = { 01240 "vc1", 01241 NULL_IF_CONFIG_SMALL("raw VC-1"), 01242 0, 01243 NULL /* vc1_probe */, 01244 video_read_header, 01245 ff_raw_read_partial_packet, 01246 .extensions = "vc1", 01247 .value = CODEC_ID_VC1, 01248 }; 01249 #endif 01250 01251 /* PCM formats */ 01252 01253 #define PCMINPUTDEF(name, long_name, ext, codec) \ 01254 AVInputFormat pcm_ ## name ## _demuxer = {\ 01255 #name,\ 01256 NULL_IF_CONFIG_SMALL(long_name),\ 01257 0,\ 01258 NULL,\ 01259 raw_read_header,\ 01260 raw_read_packet,\ 01261 NULL,\ 01262 pcm_read_seek,\ 01263 .flags= AVFMT_GENERIC_INDEX,\ 01264 .extensions = ext,\ 01265 .value = codec,\ 01266 }; 01267 01268 #define PCMOUTPUTDEF(name, long_name, ext, codec) \ 01269 AVOutputFormat pcm_ ## name ## _muxer = {\ 01270 #name,\ 01271 NULL_IF_CONFIG_SMALL(long_name),\ 01272 NULL,\ 01273 ext,\ 01274 0,\ 01275 codec,\ 01276 CODEC_ID_NONE,\ 01277 NULL,\ 01278 raw_write_packet,\ 01279 .flags= AVFMT_NOTIMESTAMPS,\ 01280 }; 01281 01282 01283 #if !CONFIG_MUXERS && CONFIG_DEMUXERS 01284 #define PCMDEF(name, long_name, ext, codec) \ 01285 PCMINPUTDEF(name, long_name, ext, codec) 01286 #elif CONFIG_MUXERS && !CONFIG_DEMUXERS 01287 #define PCMDEF(name, long_name, ext, codec) \ 01288 PCMOUTPUTDEF(name, long_name, ext, codec) 01289 #elif CONFIG_MUXERS && CONFIG_DEMUXERS 01290 #define PCMDEF(name, long_name, ext, codec) \ 01291 PCMINPUTDEF(name, long_name, ext, codec)\ 01292 PCMOUTPUTDEF(name, long_name, ext, codec) 01293 #else 01294 #define PCMDEF(name, long_name, ext, codec) 01295 #endif 01296 01297 #if HAVE_BIGENDIAN 01298 #define BE_DEF(s) s 01299 #define LE_DEF(s) NULL 01300 #else 01301 #define BE_DEF(s) NULL 01302 #define LE_DEF(s) s 01303 #endif 01304 01305 PCMDEF(f64be, "PCM 64 bit floating-point big-endian format", 01306 NULL, CODEC_ID_PCM_F64BE) 01307 01308 PCMDEF(f64le, "PCM 64 bit floating-point little-endian format", 01309 NULL, CODEC_ID_PCM_F64LE) 01310 01311 PCMDEF(f32be, "PCM 32 bit floating-point big-endian format", 01312 NULL, CODEC_ID_PCM_F32BE) 01313 01314 PCMDEF(f32le, "PCM 32 bit floating-point little-endian format", 01315 NULL, CODEC_ID_PCM_F32LE) 01316 01317 PCMDEF(s32be, "PCM signed 32 bit big-endian format", 01318 NULL, CODEC_ID_PCM_S32BE) 01319 01320 PCMDEF(s32le, "PCM signed 32 bit little-endian format", 01321 NULL, CODEC_ID_PCM_S32LE) 01322 01323 PCMDEF(s24be, "PCM signed 24 bit big-endian format", 01324 NULL, CODEC_ID_PCM_S24BE) 01325 01326 PCMDEF(s24le, "PCM signed 24 bit little-endian format", 01327 NULL, CODEC_ID_PCM_S24LE) 01328 01329 PCMDEF(s16be, "PCM signed 16 bit big-endian format", 01330 BE_DEF("sw"), CODEC_ID_PCM_S16BE) 01331 01332 PCMDEF(s16le, "PCM signed 16 bit little-endian format", 01333 LE_DEF("sw"), CODEC_ID_PCM_S16LE) 01334 01335 PCMDEF(s8, "PCM signed 8 bit format", 01336 "sb", CODEC_ID_PCM_S8) 01337 01338 PCMDEF(u32be, "PCM unsigned 32 bit big-endian format", 01339 NULL, CODEC_ID_PCM_U32BE) 01340 01341 PCMDEF(u32le, "PCM unsigned 32 bit little-endian format", 01342 NULL, CODEC_ID_PCM_U32LE) 01343 01344 PCMDEF(u24be, "PCM unsigned 24 bit big-endian format", 01345 NULL, CODEC_ID_PCM_U24BE) 01346 01347 PCMDEF(u24le, "PCM unsigned 24 bit little-endian format", 01348 NULL, CODEC_ID_PCM_U24LE) 01349 01350 PCMDEF(u16be, "PCM unsigned 16 bit big-endian format", 01351 BE_DEF("uw"), CODEC_ID_PCM_U16BE) 01352 01353 PCMDEF(u16le, "PCM unsigned 16 bit little-endian format", 01354 LE_DEF("uw"), CODEC_ID_PCM_U16LE) 01355 01356 PCMDEF(u8, "PCM unsigned 8 bit format", 01357 "ub", CODEC_ID_PCM_U8) 01358 01359 PCMDEF(alaw, "PCM A-law format", 01360 "al", CODEC_ID_PCM_ALAW) 01361 01362 PCMDEF(mulaw, "PCM mu-law format", 01363 "ul", CODEC_ID_PCM_MULAW)