FFmpeg: libavformat/raw.c Source File

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