MythTV: 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 #include "avformat.h"
00023 #include "ac3_parser.h"
00024 #include "raw.h"
00025 
00026 #ifdef CONFIG_MUXERS
00027 /* simple formats */
00028 static int flac_write_header(struct AVFormatContext *s)
00029 {
00030     static const uint8_t header[8] = {
00031         0x66, 0x4C, 0x61, 0x43, 0x80, 0x00, 0x00, 0x22
00032     };
00033     uint8_t *streaminfo = s->streams[0]->codec->extradata;
00034     int len = s->streams[0]->codec->extradata_size;
00035     if(streaminfo != NULL && len > 0) {
00036         put_buffer(&s->pb, header, 8);
00037         put_buffer(&s->pb, streaminfo, len);
00038     }
00039     return 0;
00040 }
00041 
00042 
00043 static int roq_write_header(struct AVFormatContext *s)
00044 {
00045     static const uint8_t header[] = {
00046         0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00
00047     };
00048 
00049     put_buffer(&s->pb, header, 8);
00050     put_flush_packet(&s->pb);
00051 
00052     return 0;
00053 }
00054 
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 //CONFIG_MUXERS
00062 
00063 /* raw input */
00064 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
00065 {
00066     AVStream *st;
00067     int id;
00068 
00069     st = av_new_stream(s, 0);
00070     if (!st)
00071         return AVERROR(ENOMEM);
00072 
00073         id = s->iformat->value;
00074         if (id == CODEC_ID_RAWVIDEO) {
00075             st->codec->codec_type = CODEC_TYPE_VIDEO;
00076         } else {
00077             st->codec->codec_type = CODEC_TYPE_AUDIO;
00078         }
00079         st->codec->codec_id = id;
00080 
00081         switch(st->codec->codec_type) {
00082         case CODEC_TYPE_AUDIO:
00083             st->codec->sample_rate = ap->sample_rate;
00084             st->codec->channels = ap->channels;
00085             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
00086             break;
00087         case CODEC_TYPE_VIDEO:
00088             av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
00089             st->codec->width = ap->width;
00090             st->codec->height = ap->height;
00091             st->codec->pix_fmt = ap->pix_fmt;
00092             if(st->codec->pix_fmt == PIX_FMT_NONE)
00093                 st->codec->pix_fmt= PIX_FMT_YUV420P;
00094             break;
00095         default:
00096             return -1;
00097         }
00098     return 0;
00099 }
00100 
00101 #define RAW_PACKET_SIZE 1024
00102 
00103 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
00104 {
00105     int ret, size;
00106     //    AVStream *st = s->streams[0];
00107 
00108     size= RAW_PACKET_SIZE;
00109 
00110     ret= av_get_packet(&s->pb, pkt, size);
00111 
00112     pkt->stream_index = 0;
00113     if (ret <= 0) {
00114         return AVERROR(EIO);
00115     }
00116     /* note: we need to modify the packet size here to handle the last
00117        packet */
00118     pkt->size = ret;
00119     return ret;
00120 }
00121 
00122 static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
00123 {
00124     int ret, size;
00125 
00126     size = RAW_PACKET_SIZE;
00127 
00128     if (av_new_packet(pkt, size) < 0)
00129         return AVERROR(EIO);
00130 
00131     pkt->pos= url_ftell(&s->pb);
00132     pkt->stream_index = 0;
00133     ret = get_partial_buffer(&s->pb, pkt->data, size);
00134     if (ret <= 0) {
00135         av_free_packet(pkt);
00136         return AVERROR(EIO);
00137     }
00138     pkt->size = ret;
00139     return ret;
00140 }
00141 
00142 // http://www.artificis.hu/files/texts/ingenient.txt
00143 static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
00144 {
00145     int ret, size, w, h, unk1, unk2;
00146 
00147     if (get_le32(&s->pb) != MKTAG('M', 'J', 'P', 'G'))
00148         return AVERROR(EIO); // FIXME
00149 
00150     size = get_le32(&s->pb);
00151 
00152     w = get_le16(&s->pb);
00153     h = get_le16(&s->pb);
00154 
00155     url_fskip(&s->pb, 8); // zero + size (padded?)
00156     url_fskip(&s->pb, 2);
00157     unk1 = get_le16(&s->pb);
00158     unk2 = get_le16(&s->pb);
00159     url_fskip(&s->pb, 22); // ascii timestamp
00160 
00161     av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
00162         size, w, h, unk1, unk2);
00163 
00164     if (av_new_packet(pkt, size) < 0)
00165         return AVERROR(EIO);
00166 
00167     pkt->pos = url_ftell(&s->pb);
00168     pkt->stream_index = 0;
00169     ret = get_buffer(&s->pb, pkt->data, size);
00170     if (ret <= 0) {
00171         av_free_packet(pkt);
00172         return AVERROR(EIO);
00173     }
00174     pkt->size = ret;
00175     return ret;
00176 }
00177 
00178 static int raw_read_close(AVFormatContext *s)
00179 {
00180     return 0;
00181 }
00182 
00183 int pcm_read_seek(AVFormatContext *s,
00184                   int stream_index, int64_t timestamp, int flags)
00185 {
00186     AVStream *st;
00187     int block_align, byte_rate;
00188     int64_t pos;
00189 
00190     st = s->streams[0];
00191 
00192     block_align = st->codec->block_align ? st->codec->block_align :
00193         (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
00194     byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :
00195         block_align * st->codec->sample_rate;
00196 
00197     if (block_align <= 0 || byte_rate <= 0)
00198         return -1;
00199 
00200     /* compute the position by aligning it to block_align */
00201     pos = av_rescale_rnd(timestamp * byte_rate,
00202                          st->time_base.num,
00203                          st->time_base.den * (int64_t)block_align,
00204                          (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
00205     pos *= block_align;
00206 
00207     /* recompute exact position */
00208     st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
00209     url_fseek(&s->pb, pos + s->data_offset, SEEK_SET);
00210     return 0;
00211 }
00212 
00213 /* ac3 read */
00214 static int ac3_read_header(AVFormatContext *s,
00215                            AVFormatParameters *ap)
00216 {
00217     AVStream *st;
00218 
00219     st = av_new_stream(s, 0);
00220     if (!st)
00221         return AVERROR(ENOMEM);
00222 
00223     st->codec->codec_type = CODEC_TYPE_AUDIO;
00224     st->codec->codec_id = CODEC_ID_AC3;
00225     st->need_parsing = AVSTREAM_PARSE_FULL;
00226     /* the parameters will be extracted from the compressed bitstream */
00227     return 0;
00228 }
00229 
00230 static int shorten_read_header(AVFormatContext *s,
00231                                AVFormatParameters *ap)
00232 {
00233     AVStream *st;
00234 
00235     st = av_new_stream(s, 0);
00236     if (!st)
00237         return AVERROR(ENOMEM);
00238     st->codec->codec_type = CODEC_TYPE_AUDIO;
00239     st->codec->codec_id = CODEC_ID_SHORTEN;
00240     st->need_parsing = AVSTREAM_PARSE_FULL;
00241     /* the parameters will be extracted from the compressed bitstream */
00242     return 0;
00243 }
00244 
00245 /* flac read */
00246 static int flac_read_header(AVFormatContext *s,
00247                             AVFormatParameters *ap)
00248 {
00249     AVStream *st;
00250 
00251     st = av_new_stream(s, 0);
00252     if (!st)
00253         return AVERROR(ENOMEM);
00254     st->codec->codec_type = CODEC_TYPE_AUDIO;
00255     st->codec->codec_id = CODEC_ID_FLAC;
00256     st->need_parsing = AVSTREAM_PARSE_FULL;
00257     /* the parameters will be extracted from the compressed bitstream */
00258     return 0;
00259 }
00260 
00261 /* dts read */
00262 static int dts_read_header(AVFormatContext *s,
00263                            AVFormatParameters *ap)
00264 {
00265     AVStream *st;
00266 
00267     st = av_new_stream(s, 0);
00268     if (!st)
00269         return AVERROR(ENOMEM);
00270 
00271     st->codec->codec_type = CODEC_TYPE_AUDIO;
00272     st->codec->codec_id = CODEC_ID_DTS;
00273     st->need_parsing = AVSTREAM_PARSE_FULL;
00274     /* the parameters will be extracted from the compressed bitstream */
00275     return 0;
00276 }
00277 
00278 /* aac read */
00279 static int aac_read_header(AVFormatContext *s,
00280                            AVFormatParameters *ap)
00281 {
00282     AVStream *st;
00283 
00284     st = av_new_stream(s, 0);
00285     if (!st)
00286         return AVERROR(ENOMEM);
00287 
00288     st->codec->codec_type = CODEC_TYPE_AUDIO;
00289     st->codec->codec_id = CODEC_ID_AAC;
00290     st->need_parsing = AVSTREAM_PARSE_FULL;
00291     /* the parameters will be extracted from the compressed bitstream */
00292     return 0;
00293 }
00294 
00295 /* mpeg1/h263 input */
00296 static int video_read_header(AVFormatContext *s,
00297                              AVFormatParameters *ap)
00298 {
00299     AVStream *st;
00300 
00301     st = av_new_stream(s, 0);
00302     if (!st)
00303         return AVERROR(ENOMEM);
00304 
00305     st->codec->codec_type = CODEC_TYPE_VIDEO;
00306     st->codec->codec_id = s->iformat->value;
00307     st->need_parsing = AVSTREAM_PARSE_FULL;
00308 
00309     /* for mjpeg, specify frame rate */
00310     /* for mpeg4 specify it too (most mpeg4 streams do not have the fixed_vop_rate set ...)*/
00311     if (ap->time_base.num) {
00312         av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
00313     } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
00314                 st->codec->codec_id == CODEC_ID_MPEG4 ||
00315                 st->codec->codec_id == CODEC_ID_H264) {
00316         av_set_pts_info(st, 64, 1, 25);
00317     }
00318 
00319     return 0;
00320 }
00321 
00322 #define SEQ_START_CODE          0x000001b3
00323 #define GOP_START_CODE          0x000001b8
00324 #define PICTURE_START_CODE      0x00000100
00325 #define SLICE_START_CODE        0x00000101
00326 #define PACK_START_CODE         0x000001ba
00327 #define VIDEO_ID                0x000001e0
00328 #define AUDIO_ID                0x000001c0
00329 
00330 static int mpegvideo_probe(AVProbeData *p)
00331 {
00332     uint32_t code= -1;
00333     int pic=0, seq=0, slice=0, pspack=0, pes=0;
00334     int i;
00335 
00336     for(i=0; i<p->buf_size; i++){
00337         code = (code<<8) + p->buf[i];
00338         if ((code & 0xffffff00) == 0x100) {
00339             switch(code){
00340             case     SEQ_START_CODE:   seq++; break;
00341             case PICTURE_START_CODE:   pic++; break;
00342             case   SLICE_START_CODE: slice++; break;
00343             case    PACK_START_CODE: pspack++; break;
00344             }
00345             if     ((code & 0x1f0) == VIDEO_ID)   pes++;
00346             else if((code & 0x1e0) == AUDIO_ID)   pes++;
00347         }
00348     }
00349     if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)
00350         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
00351     return 0;
00352 }
00353 
00354 #define VISUAL_OBJECT_START_CODE       0x000001b5
00355 #define VOP_START_CODE                 0x000001b6
00356 
00357 static int mpeg4video_probe(AVProbeData *probe_packet)
00358 {
00359     uint32_t temp_buffer= -1;
00360     int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;
00361     int i;
00362 
00363     for(i=0; i<probe_packet->buf_size; i++){
00364         temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];
00365         if ((temp_buffer & 0xffffff00) != 0x100)
00366             continue;
00367 
00368         if (temp_buffer == VOP_START_CODE)                         VOP++;
00369         else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;
00370         else if (temp_buffer < 0x120)                              VO++;
00371         else if (temp_buffer < 0x130)                              VOL++;
00372         else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)
00373                  && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;
00374     }
00375 
00376     if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)
00377         return AVPROBE_SCORE_MAX/2;
00378     return 0;
00379 }
00380 
00381 static int h263_probe(AVProbeData *p)
00382 {
00383     int code;
00384     const uint8_t *d;
00385 
00386     d = p->buf;
00387     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
00388     if (code == 0x20) {
00389         return 50;
00390     }
00391     return 0;
00392 }
00393 
00394 static int h261_probe(AVProbeData *p)
00395 {
00396     int code;
00397     const uint8_t *d;
00398 
00399     d = p->buf;
00400     code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
00401     if (code == 0x10) {
00402         return 50;
00403     }
00404     return 0;
00405 }
00406 
00407 static int ac3_probe(AVProbeData *p)
00408 {
00409     int max_frames, first_frames = 0, frames;
00410     uint8_t *buf, *buf2, *end;
00411     AC3HeaderInfo hdr;
00412 
00413     max_frames = 0;
00414     buf = p->buf;
00415     end = buf + p->buf_size;
00416 
00417     for(; buf < end; buf++) {
00418         buf2 = buf;
00419 
00420         for(frames = 0; buf2 < end; frames++) {
00421             if(ff_ac3_parse_header(buf2, &hdr) < 0)
00422                 break;
00423             buf2 += hdr.frame_size;
00424         }
00425         max_frames = FFMAX(max_frames, frames);
00426         if(buf == p->buf)
00427             first_frames = frames;
00428     }
00429     if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
00430     else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
00431     else if(max_frames>=1) return 1;
00432     else                   return 0;
00433 }
00434 
00435 static int flac_probe(AVProbeData *p)
00436 {
00437     if(memcmp(p->buf, "fLaC", 4)) return 0;
00438     else                          return AVPROBE_SCORE_MAX / 2;
00439 }
00440 
00441 AVInputFormat shorten_demuxer = {
00442     "shn",
00443     "raw shorten",
00444     0,
00445     NULL,
00446     shorten_read_header,
00447     raw_read_partial_packet,
00448     raw_read_close,
00449     .flags= AVFMT_GENERIC_INDEX,
00450     .extensions = "shn",
00451 };
00452 
00453 AVInputFormat flac_demuxer = {
00454     "flac",
00455     "raw flac",
00456     0,
00457     flac_probe,
00458     flac_read_header,
00459     raw_read_partial_packet,
00460     raw_read_close,
00461     .flags= AVFMT_GENERIC_INDEX,
00462     .extensions = "flac",
00463 };
00464 
00465 #ifdef CONFIG_MUXERS
00466 AVOutputFormat flac_muxer = {
00467     "flac",
00468     "raw flac",
00469     "audio/x-flac",
00470     "flac",
00471     0,
00472     CODEC_ID_FLAC,
00473     0,
00474     flac_write_header,
00475     raw_write_packet,
00476     .flags= AVFMT_NOTIMESTAMPS,
00477 };
00478 #endif //CONFIG_MUXERS
00479 
00480 #ifdef CONFIG_AC3_DEMUXER
00481 AVInputFormat ac3_demuxer = {
00482     "ac3",
00483     "raw ac3",
00484     0,
00485     ac3_probe,
00486     ac3_read_header,
00487     raw_read_partial_packet,
00488     raw_read_close,
00489     .flags= AVFMT_GENERIC_INDEX,
00490     .extensions = "ac3",
00491 };
00492 #endif
00493 
00494 #ifdef CONFIG_MUXERS
00495 AVOutputFormat ac3_muxer = {
00496     "ac3",
00497     "raw ac3",
00498     "audio/x-ac3",
00499     "ac3",
00500     0,
00501     CODEC_ID_AC3,
00502     0,
00503     NULL,
00504     raw_write_packet,
00505     .flags= AVFMT_NOTIMESTAMPS,
00506 };
00507 #endif //CONFIG_MUXERS
00508 
00509 AVInputFormat dts_demuxer = {
00510     "dts",
00511     "raw dts",
00512     0,
00513     NULL,
00514     dts_read_header,
00515     raw_read_partial_packet,
00516     raw_read_close,
00517     .flags= AVFMT_GENERIC_INDEX,
00518     .extensions = "dts",
00519 };
00520 
00521 AVInputFormat aac_demuxer = {
00522     "aac",
00523     "ADTS AAC",
00524     0,
00525     NULL,
00526     aac_read_header,
00527     raw_read_partial_packet,
00528     raw_read_close,
00529     .flags= AVFMT_GENERIC_INDEX,
00530     .extensions = "aac",
00531 };
00532 
00533 #ifdef CONFIG_ROQ_MUXER
00534 AVOutputFormat roq_muxer =
00535 {
00536     "RoQ",
00537     "Id RoQ format",
00538     NULL,
00539     "roq",
00540     0,
00541     CODEC_ID_ROQ_DPCM,
00542     CODEC_ID_ROQ,
00543     roq_write_header,
00544     raw_write_packet,
00545 };
00546 #endif //CONFIG_ROQ_MUXER
00547 
00548 AVInputFormat h261_demuxer = {
00549     "h261",
00550     "raw h261",
00551     0,
00552     h261_probe,
00553     video_read_header,
00554     raw_read_partial_packet,
00555     raw_read_close,
00556     .flags= AVFMT_GENERIC_INDEX,
00557     .extensions = "h261",
00558     .value = CODEC_ID_H261,
00559 };
00560 
00561 #ifdef CONFIG_MUXERS
00562 AVOutputFormat h261_muxer = {
00563     "h261",
00564     "raw h261",
00565     "video/x-h261",
00566     "h261",
00567     0,
00568     0,
00569     CODEC_ID_H261,
00570     NULL,
00571     raw_write_packet,
00572     .flags= AVFMT_NOTIMESTAMPS,
00573 };
00574 #endif //CONFIG_MUXERS
00575 
00576 AVInputFormat h263_demuxer = {
00577     "h263",
00578     "raw h263",
00579     0,
00580     h263_probe,
00581     video_read_header,
00582     raw_read_partial_packet,
00583     raw_read_close,
00584     .flags= AVFMT_GENERIC_INDEX,
00585 //    .extensions = "h263", //FIXME remove after writing mpeg4_probe
00586     .value = CODEC_ID_H263,
00587 };
00588 
00589 #ifdef CONFIG_MUXERS
00590 AVOutputFormat h263_muxer = {
00591     "h263",
00592     "raw h263",
00593     "video/x-h263",
00594     "h263",
00595     0,
00596     0,
00597     CODEC_ID_H263,
00598     NULL,
00599     raw_write_packet,
00600     .flags= AVFMT_NOTIMESTAMPS,
00601 };
00602 #endif //CONFIG_MUXERS
00603 
00604 AVInputFormat m4v_demuxer = {
00605     "m4v",
00606     "raw MPEG4 video format",
00607     0,
00608     mpeg4video_probe, 
00609     video_read_header,
00610     raw_read_partial_packet,
00611     raw_read_close,
00612     .flags= AVFMT_GENERIC_INDEX,
00613     .extensions = "m4v", //FIXME remove after writing mpeg4_probe
00614     .value = CODEC_ID_MPEG4,
00615 };
00616 
00617 #ifdef CONFIG_MUXERS
00618 AVOutputFormat m4v_muxer = {
00619     "m4v",
00620     "raw MPEG4 video format",
00621     NULL,
00622     "m4v",
00623     0,
00624     CODEC_ID_NONE,
00625     CODEC_ID_MPEG4,
00626     NULL,
00627     raw_write_packet,
00628     .flags= AVFMT_NOTIMESTAMPS,
00629 };
00630 #endif //CONFIG_MUXERS
00631 
00632 AVInputFormat h264_demuxer = {
00633     "h264",
00634     "raw H264 video format",
00635     0,
00636     NULL /*mpegvideo_probe*/,
00637     video_read_header,
00638     raw_read_partial_packet,
00639     raw_read_close,
00640     .flags= AVFMT_GENERIC_INDEX,
00641     .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
00642     .value = CODEC_ID_H264,
00643 };
00644 
00645 #ifdef CONFIG_MUXERS
00646 AVOutputFormat h264_muxer = {
00647     "h264",
00648     "raw H264 video format",
00649     NULL,
00650     "h264",
00651     0,
00652     CODEC_ID_NONE,
00653     CODEC_ID_H264,
00654     NULL,
00655     raw_write_packet,
00656     .flags= AVFMT_NOTIMESTAMPS,
00657 };
00658 #endif //CONFIG_MUXERS
00659 
00660 AVInputFormat mpegvideo_demuxer = {
00661     "mpegvideo",
00662     "MPEG video",
00663     0,
00664     mpegvideo_probe,
00665     video_read_header,
00666     raw_read_partial_packet,
00667     raw_read_close,
00668     .flags= AVFMT_GENERIC_INDEX,
00669     .value = CODEC_ID_MPEG1VIDEO,
00670 };
00671 
00672 #ifdef CONFIG_MUXERS
00673 AVOutputFormat mpeg1video_muxer = {
00674     "mpeg1video",
00675     "MPEG video",
00676     "video/x-mpeg",
00677     "mpg,mpeg,m1v",
00678     0,
00679     0,
00680     CODEC_ID_MPEG1VIDEO,
00681     NULL,
00682     raw_write_packet,
00683     .flags= AVFMT_NOTIMESTAMPS,
00684 };
00685 #endif //CONFIG_MUXERS
00686 
00687 #ifdef CONFIG_MUXERS
00688 AVOutputFormat mpeg2video_muxer = {
00689     "mpeg2video",
00690     "MPEG2 video",
00691     NULL,
00692     "m2v",
00693     0,
00694     0,
00695     CODEC_ID_MPEG2VIDEO,
00696     NULL,
00697     raw_write_packet,
00698     .flags= AVFMT_NOTIMESTAMPS,
00699 };
00700 #endif //CONFIG_MUXERS
00701 
00702 AVInputFormat mjpeg_demuxer = {
00703     "mjpeg",
00704     "MJPEG video",
00705     0,
00706     NULL,
00707     video_read_header,
00708     raw_read_partial_packet,
00709     raw_read_close,
00710     .flags= AVFMT_GENERIC_INDEX,
00711     .extensions = "mjpg,mjpeg",
00712     .value = CODEC_ID_MJPEG,
00713 };
00714 
00715 AVInputFormat ingenient_demuxer = {
00716     "ingenient",
00717     "Ingenient MJPEG",
00718     0,
00719     NULL,
00720     video_read_header,
00721     ingenient_read_packet,
00722     raw_read_close,
00723     .flags= AVFMT_GENERIC_INDEX,
00724     .extensions = "cgi", // FIXME
00725     .value = CODEC_ID_MJPEG,
00726 };
00727 
00728 #ifdef CONFIG_MUXERS
00729 AVOutputFormat mjpeg_muxer = {
00730     "mjpeg",
00731     "MJPEG video",
00732     "video/x-mjpeg",
00733     "mjpg,mjpeg",
00734     0,
00735     0,
00736     CODEC_ID_MJPEG,
00737     NULL,
00738     raw_write_packet,
00739     .flags= AVFMT_NOTIMESTAMPS,
00740 };
00741 #endif //CONFIG_MUXERS
00742 
00743 AVInputFormat vc1_demuxer = {
00744     "vc1",
00745     "raw vc1",
00746     0,
00747     NULL /* vc1_probe */,
00748     video_read_header,
00749     raw_read_partial_packet,
00750     raw_read_close,
00751     .extensions = "vc1",
00752     .value = CODEC_ID_VC1,
00753 };
00754 
00755 /* pcm formats */
00756 
00757 #define PCMINPUTDEF(name, long_name, ext, codec) \
00758 AVInputFormat pcm_ ## name ## _demuxer = {\
00759     #name,\
00760     long_name,\
00761     0,\
00762     NULL,\
00763     raw_read_header,\
00764     raw_read_packet,\
00765     raw_read_close,\
00766     pcm_read_seek,\
00767     .flags= AVFMT_GENERIC_INDEX,\
00768     .extensions = ext,\
00769     .value = codec,\
00770 };
00771 
00772 #define PCMOUTPUTDEF(name, long_name, ext, codec) \
00773 AVOutputFormat pcm_ ## name ## _muxer = {\
00774     #name,\
00775     long_name,\
00776     NULL,\
00777     ext,\
00778     0,\
00779     codec,\
00780     0,\
00781     NULL,\
00782     raw_write_packet,\
00783     .flags= AVFMT_NOTIMESTAMPS,\
00784 };
00785 
00786 
00787 #if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
00788 #define PCMDEF(name, long_name, ext, codec) \
00789         PCMINPUTDEF(name, long_name, ext, codec)
00790 #elif defined(CONFIG_MUXERS) && !defined(CONFIG_DEMUXERS)
00791 #define PCMDEF(name, long_name, ext, codec) \
00792         PCMOUTPUTDEF(name, long_name, ext, codec)
00793 #elif defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
00794 #define PCMDEF(name, long_name, ext, codec) \
00795         PCMINPUTDEF(name, long_name, ext, codec)\
00796         PCMOUTPUTDEF(name, long_name, ext, codec)
00797 #else
00798 #define PCMDEF(name, long_name, ext, codec)
00799 #endif
00800 
00801 #ifdef WORDS_BIGENDIAN
00802 #define BE_DEF(s) s
00803 #define LE_DEF(s) NULL
00804 #else
00805 #define BE_DEF(s) NULL
00806 #define LE_DEF(s) s
00807 #endif
00808 
00809 
00810 PCMDEF(s16le, "pcm signed 16 bit little endian format",
00811        LE_DEF("sw"), CODEC_ID_PCM_S16LE)
00812 
00813 PCMDEF(s16be, "pcm signed 16 bit big endian format",
00814        BE_DEF("sw"), CODEC_ID_PCM_S16BE)
00815 
00816 PCMDEF(u16le, "pcm unsigned 16 bit little endian format",
00817        LE_DEF("uw"), CODEC_ID_PCM_U16LE)
00818 
00819 PCMDEF(u16be, "pcm unsigned 16 bit big endian format",
00820        BE_DEF("uw"), CODEC_ID_PCM_U16BE)
00821 
00822 PCMDEF(s8, "pcm signed 8 bit format",
00823        "sb", CODEC_ID_PCM_S8)
00824 
00825 PCMDEF(u8, "pcm unsigned 8 bit format",
00826        "ub", CODEC_ID_PCM_U8)
00827 
00828 PCMDEF(mulaw, "pcm mu law format",
00829        "ul", CODEC_ID_PCM_MULAW)
00830 
00831 PCMDEF(alaw, "pcm A law format",
00832        "al", CODEC_ID_PCM_ALAW)
00833 
00834 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
00835 {
00836     int packet_size, ret, width, height;
00837     AVStream *st = s->streams[0];
00838 
00839     width = st->codec->width;
00840     height = st->codec->height;
00841 
00842     packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
00843     if (packet_size < 0)
00844         return -1;
00845 
00846     ret= av_get_packet(&s->pb, pkt, packet_size);
00847 
00848     pkt->stream_index = 0;
00849     if (ret != packet_size) {
00850         return AVERROR(EIO);
00851     } else {
00852         return 0;
00853     }
00854 }
00855 
00856 AVInputFormat rawvideo_demuxer = {
00857     "rawvideo",
00858     "raw video format",
00859     0,
00860     NULL,
00861     raw_read_header,
00862     rawvideo_read_packet,
00863     raw_read_close,
00864     .flags= AVFMT_GENERIC_INDEX,
00865     .extensions = "yuv,cif,qcif,rgb",
00866     .value = CODEC_ID_RAWVIDEO,
00867 };
00868 
00869 #ifdef CONFIG_MUXERS
00870 AVOutputFormat rawvideo_muxer = {
00871     "rawvideo",
00872     "raw video format",
00873     NULL,
00874     "yuv,rgb",
00875     0,
00876     CODEC_ID_NONE,
00877     CODEC_ID_RAWVIDEO,
00878     NULL,
00879     raw_write_packet,
00880     .flags= AVFMT_NOTIMESTAMPS,
00881 };
00882 #endif //CONFIG_MUXERS
00883 
00884 #ifdef CONFIG_MUXERS
00885 static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
00886 {
00887     return 0;
00888 }
00889 
00890 AVOutputFormat null_muxer = {
00891     "null",
00892     "null video format",
00893     NULL,
00894     NULL,
00895     0,
00896 #ifdef WORDS_BIGENDIAN
00897     CODEC_ID_PCM_S16BE,
00898 #else
00899     CODEC_ID_PCM_S16LE,
00900 #endif
00901     CODEC_ID_RAWVIDEO,
00902     NULL,
00903     null_write_packet,
00904     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
00905 };
00906 #endif //CONFIG_MUXERS