git.sesse.net Git - ffmpeg/blob - libavformat/raw.c

   1 /*
   2  * RAW muxer and demuxer
   3  * Copyright (c) 2001 Fabrice Bellard.
   4  * Copyright (c) 2005 Alex Beregszaszi
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "libavutil/crc.h"
  24 #include "libavcodec/ac3_parser.h"
  25 #include "libavcodec/bitstream.h"
  26 #include "libavcodec/bytestream.h"
  27 #include "avformat.h"
  28 #include "raw.h"
  29
  30 #ifdef CONFIG_MUXERS
  31 /* simple formats */
  32 static int flac_write_header(struct AVFormatContext *s)
  33 {
  34     static const uint8_t header[8] = {
  35         0x66, 0x4C, 0x61, 0x43, 0x80, 0x00, 0x00, 0x22
  36     };
  37     uint8_t *streaminfo = s->streams[0]->codec->extradata;
  38     int len = s->streams[0]->codec->extradata_size;
  39     if(streaminfo != NULL && len > 0) {
  40         put_buffer(s->pb, header, 8);
  41         put_buffer(s->pb, streaminfo, len);
  42     }
  43     return 0;
  44 }
  45
  46
  47 static int roq_write_header(struct AVFormatContext *s)
  48 {
  49     static const uint8_t header[] = {
  50         0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00
  51     };
  52
  53     put_buffer(s->pb, header, 8);
  54     put_flush_packet(s->pb);
  55
  56     return 0;
  57 }
  58
  59 static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
  60 {
  61     return 0;
  62 }
  63
  64 static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)
  65 {
  66     put_buffer(s->pb, pkt->data, pkt->size);
  67     put_flush_packet(s->pb);
  68     return 0;
  69 }
  70 #endif //CONFIG_MUXERS
  71
  72 /* raw input */
  73 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
  74 {
  75     AVStream *st;
  76     int id;
  77
  78     st = av_new_stream(s, 0);
  79     if (!st)
  80         return AVERROR(ENOMEM);
  81
  82         id = s->iformat->value;
  83         if (id == CODEC_ID_RAWVIDEO) {
  84             st->codec->codec_type = CODEC_TYPE_VIDEO;
  85         } else {
  86             st->codec->codec_type = CODEC_TYPE_AUDIO;
  87         }
  88         st->codec->codec_id = id;
  89
  90         switch(st->codec->codec_type) {
  91         case CODEC_TYPE_AUDIO:
  92             st->codec->sample_rate = ap->sample_rate;
  93             st->codec->channels = ap->channels;
  94             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
  95             break;
  96         case CODEC_TYPE_VIDEO:
  97             if(ap->time_base.num)
  98                 av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
  99             else
 100                 av_set_pts_info(st, 64, 1, 25);
 101             st->codec->width = ap->width;
 102             st->codec->height = ap->height;
 103             st->codec->pix_fmt = ap->pix_fmt;
 104             if(st->codec->pix_fmt == PIX_FMT_NONE)
 105                 st->codec->pix_fmt= PIX_FMT_YUV420P;
 106             break;
 107         default:
 108             return -1;
 109         }
 110     return 0;
 111 }
 112
 113 #define RAW_PACKET_SIZE 1024
 114
 115 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
 116 {
 117     int ret, size, bps;
 118     //    AVStream *st = s->streams[0];
 119
 120     size= RAW_PACKET_SIZE;
 121
 122     ret= av_get_packet(s->pb, pkt, size);
 123
 124     pkt->stream_index = 0;
 125     if (ret <= 0) {
 126         return AVERROR(EIO);
 127     }
 128     /* note: we need to modify the packet size here to handle the last
 129        packet */
 130     pkt->size = ret;
 131
 132     bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id);
 133     assert(bps); // if false there IS a bug elsewhere (NOT in this function)
 134     pkt->dts=
 135     pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels);
 136
 137     return ret;
 138 }
 139
 140 static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
 141 {
 142     int ret, size;
 143
 144     size = RAW_PACKET_SIZE;
 145
 146     if (av_new_packet(pkt, size) < 0)
 147         return AVERROR(EIO);
 148
 149     pkt->pos= url_ftell(s->pb);
 150     pkt->stream_index = 0;
 151     ret = get_partial_buffer(s->pb, pkt->data, size);
 152     if (ret <= 0) {
 153         av_free_packet(pkt);
 154         return AVERROR(EIO);
 155     }
 156     pkt->size = ret;
 157     return ret;
 158 }
 159
 160 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
 161 {
 162     int packet_size, ret, width, height;
 163     AVStream *st = s->streams[0];
 164
 165     width = st->codec->width;
 166     height = st->codec->height;
 167
 168     packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
 169     if (packet_size < 0)
 170         return -1;
 171
 172     ret= av_get_packet(s->pb, pkt, packet_size);
 173     pkt->pts=
 174     pkt->dts= pkt->pos / packet_size;
 175
 176     pkt->stream_index = 0;
 177     if (ret != packet_size) {
 178         return AVERROR(EIO);
 179     } else {
 180         return 0;
 181     }
 182 }
 183
 184 // http://www.artificis.hu/files/texts/ingenient.txt
 185 static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
 186 {
 187     int ret, size, w, h, unk1, unk2;
 188
 189     if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))
 190         return AVERROR(EIO); // FIXME
 191
 192     size = get_le32(s->pb);
 193
 194     w = get_le16(s->pb);
 195     h = get_le16(s->pb);
 196
 197     url_fskip(s->pb, 8); // zero + size (padded?)
 198     url_fskip(s->pb, 2);
 199     unk1 = get_le16(s->pb);
 200     unk2 = get_le16(s->pb);
 201     url_fskip(s->pb, 22); // ascii timestamp
 202
 203     av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
 204         size, w, h, unk1, unk2);
 205
 206     if (av_new_packet(pkt, size) < 0)
 207         return AVERROR(EIO);
 208
 209     pkt->pos = url_ftell(s->pb);
 210     pkt->stream_index = 0;
 211     ret = get_buffer(s->pb, pkt->data, size);
 212     if (ret <= 0) {
 213         av_free_packet(pkt);
 214         return AVERROR(EIO);
 215     }
 216     pkt->size = ret;
 217     return ret;
 218 }
 219
 220 int pcm_read_seek(AVFormatContext *s,
 221                   int stream_index, int64_t timestamp, int flags)
 222 {
 223     AVStream *st;
 224     int block_align, byte_rate;
 225     int64_t pos;
 226
 227     st = s->streams[0];
 228
 229     block_align = st->codec->block_align ? st->codec->block_align :
 230         (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
 231     byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :
 232         block_align * st->codec->sample_rate;
 233
 234     if (block_align <= 0 || byte_rate <= 0)
 235         return -1;
 236
 237     /* compute the position by aligning it to block_align */
 238     pos = av_rescale_rnd(timestamp * byte_rate,
 239                          st->time_base.num,
 240                          st->time_base.den * (int64_t)block_align,
 241                          (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
 242     pos *= block_align;
 243
 244     /* recompute exact position */
 245     st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
 246     url_fseek(s->pb, pos + s->data_offset, SEEK_SET);
 247     return 0;
 248 }
 249
 250 static int audio_read_header(AVFormatContext *s,
 251                              AVFormatParameters *ap)
 252 {
 253     AVStream *st = av_new_stream(s, 0);
 254     if (!st)
 255         return AVERROR(ENOMEM);
 256     st->codec->codec_type = CODEC_TYPE_AUDIO;
 257     st->codec->codec_id = s->iformat->value;
 258     st->need_parsing = AVSTREAM_PARSE_FULL;
 259     /* the parameters will be extracted from the compressed bitstream */
 260     return 0;
 261 }
 262
 263 /* mpeg1/h263 input */
 264 static int video_read_header(AVFormatContext *s,
 265                              AVFormatParameters *ap)
 266 {
 267     AVStream *st;
 268
 269     st = av_new_stream(s, 0);
 270     if (!st)
 271         return AVERROR(ENOMEM);
 272
 273     st->codec->codec_type = CODEC_TYPE_VIDEO;
 274     st->codec->codec_id = s->iformat->value;
 275     st->need_parsing = AVSTREAM_PARSE_FULL;
 276
 277     /* for mjpeg, specify frame rate */
 278     /* for mpeg4 specify it too (most mpeg4 streams do not have the fixed_vop_rate set ...)*/
 279     if (ap->time_base.num) {
 280         av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
 281     } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
 282                 st->codec->codec_id == CODEC_ID_MPEG4 ||
 283                 st->codec->codec_id == CODEC_ID_DIRAC ||
 284                 st->codec->codec_id == CODEC_ID_H264) {
 285         av_set_pts_info(st, 64, 1, 25);
 286     }
 287
 288     return 0;
 289 }
 290
 291 #define SEQ_START_CODE          0x000001b3
 292 #define GOP_START_CODE          0x000001b8
 293 #define PICTURE_START_CODE      0x00000100
 294 #define SLICE_START_CODE        0x00000101
 295 #define PACK_START_CODE         0x000001ba
 296 #define VIDEO_ID                0x000001e0
 297 #define AUDIO_ID                0x000001c0
 298
 299 static int mpegvideo_probe(AVProbeData *p)
 300 {
 301     uint32_t code= -1;
 302     int pic=0, seq=0, slice=0, pspack=0, pes=0;
 303     int i;
 304
 305     for(i=0; i<p->buf_size; i++){
 306         code = (code<<8) + p->buf[i];
 307         if ((code & 0xffffff00) == 0x100) {
 308             switch(code){
 309             case     SEQ_START_CODE:   seq++; break;
 310             case PICTURE_START_CODE:   pic++; break;
 311             case   SLICE_START_CODE: slice++; break;
 312             case    PACK_START_CODE: pspack++; break;
 313             }
 314             if     ((code & 0x1f0) == VIDEO_ID)   pes++;
 315             else if((code & 0x1e0) == AUDIO_ID)   pes++;
 316         }
 317     }
 318     if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)
 319         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
 320     return 0;
 321 }
 322
 323 #define VISUAL_OBJECT_START_CODE       0x000001b5
 324 #define VOP_START_CODE                 0x000001b6
 325
 326 static int mpeg4video_probe(AVProbeData *probe_packet)
 327 {
 328     uint32_t temp_buffer= -1;
 329     int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;
 330     int i;
 331
 332     for(i=0; i<probe_packet->buf_size; i++){
 333         temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];
 334         if ((temp_buffer & 0xffffff00) != 0x100)
 335             continue;
 336
 337         if (temp_buffer == VOP_START_CODE)                         VOP++;
 338         else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;
 339         else if (temp_buffer < 0x120)                              VO++;
 340         else if (temp_buffer < 0x130)                              VOL++;
 341         else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)
 342                  && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;
 343     }
 344
 345     if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)
 346         return AVPROBE_SCORE_MAX/2;
 347     return 0;
 348 }
 349
 350 static int h264_probe(AVProbeData *p)
 351 {
 352     uint32_t code= -1;
 353     int sps=0, pps=0, idr=0, res=0;
 354     int i;
 355
 356     for(i=0; i<p->buf_size; i++){
 357         code = (code<<8) + p->buf[i];
 358         if ((code & 0xffffff00) == 0x100) {
 359             int ref_idc= (code>>5)&3;
 360             int type   = code & 0x1F;
 361             static const int8_t ref_zero[32]={
 362                 2, 0, 0, 0, 0,-1, 1,-1,
 363                -1, 1, 1, 1, 1,-1, 2, 2,
 364                 2, 2, 2, 0, 2, 2, 2, 2,
 365                 2, 2, 2, 2, 2, 2, 2, 2
 366             };
 367
 368             if(code & 0x80) //forbidden bit
 369                 return 0;
 370
 371             if(ref_zero[type] == 1 && ref_idc)
 372                 return 0;
 373             if(ref_zero[type] ==-1 && !ref_idc)
 374                 return 0;
 375             if(ref_zero[type] == 2)
 376                 res++;
 377
 378             switch(type){
 379             case     5:   idr++; break;
 380             case     7:
 381                 if(p->buf[i+2]&0x0F)
 382                     return 0;
 383                 sps++;
 384                 break;
 385             case     8:   pps++; break;
 386             }
 387         }
 388     }
 389     if(sps && pps && idr && res<(sps+pps+idr))
 390         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
 391     return 0;
 392 }
 393
 394 static int h263_probe(AVProbeData *p)
 395 {
 396     int code;
 397     const uint8_t *d;
 398
 399     d = p->buf;
 400     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
 401     if (code == 0x20) {
 402         return 50;
 403     }
 404     return 0;
 405 }
 406
 407 static int h261_probe(AVProbeData *p)
 408 {
 409     int code;
 410     const uint8_t *d;
 411
 412     d = p->buf;
 413     code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
 414     if (code == 0x10) {
 415         return 50;
 416     }
 417     return 0;
 418 }
 419
 420 #define DCA_MARKER_14B_BE 0x1FFFE800
 421 #define DCA_MARKER_14B_LE 0xFF1F00E8
 422 #define DCA_MARKER_RAW_BE 0x7FFE8001
 423 #define DCA_MARKER_RAW_LE 0xFE7F0180
 424 static int dts_probe(AVProbeData *p)
 425 {
 426     const uint8_t *buf, *bufp;
 427     uint32_t state = -1;
 428
 429     buf = p->buf;
 430
 431     for(; buf < (p->buf+p->buf_size)-2; buf+=2) {
 432         bufp = buf;
 433         state = (state << 16) | bytestream_get_be16(&bufp);
 434
 435         /* Regular bitstream */
 436         if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)
 437             return AVPROBE_SCORE_MAX/2+1;
 438
 439         /* 14 bits big endian bitstream */
 440         if (state == DCA_MARKER_14B_BE)
 441             if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)
 442                 return AVPROBE_SCORE_MAX/2+1;
 443
 444         /* 14 bits little endian bitstream */
 445         if (state == DCA_MARKER_14B_LE)
 446             if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)
 447                 return AVPROBE_SCORE_MAX/2+1;
 448     }
 449
 450     return 0;
 451 }
 452
 453 static int dirac_probe(AVProbeData *p)
 454 {
 455     if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
 456         return AVPROBE_SCORE_MAX;
 457     else
 458         return 0;
 459 }
 460
 461 static int ac3_probe(AVProbeData *p)
 462 {
 463     int max_frames, first_frames = 0, frames;
 464     uint8_t *buf, *buf2, *end;
 465     AC3HeaderInfo hdr;
 466     GetBitContext gbc;
 467
 468     max_frames = 0;
 469     buf = p->buf;
 470     end = buf + p->buf_size;
 471
 472     for(; buf < end; buf++) {
 473         buf2 = buf;
 474
 475         for(frames = 0; buf2 < end; frames++) {
 476             init_get_bits(&gbc, buf2, 54);
 477             if(ff_ac3_parse_header(&gbc, &hdr) < 0)
 478                 break;
 479             if(buf2 + hdr.frame_size > end ||
 480                av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))
 481                 break;
 482             buf2 += hdr.frame_size;
 483         }
 484         max_frames = FFMAX(max_frames, frames);
 485         if(buf == p->buf)
 486             first_frames = frames;
 487     }
 488     if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
 489     else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
 490     else if(max_frames>=1) return 1;
 491     else                   return 0;
 492 }
 493
 494 static int flac_probe(AVProbeData *p)
 495 {
 496     if(memcmp(p->buf, "fLaC", 4)) return 0;
 497     else                          return AVPROBE_SCORE_MAX / 2;
 498 }
 499
 500
 501 /* Note: Do not forget to add new entries to the Makefile as well. */
 502
 503 AVInputFormat aac_demuxer = {
 504     "aac",
 505     NULL_IF_CONFIG_SMALL("ADTS AAC"),
 506     0,
 507     NULL,
 508     audio_read_header,
 509     raw_read_partial_packet,
 510     .flags= AVFMT_GENERIC_INDEX,
 511     .extensions = "aac",
 512     .value = CODEC_ID_AAC,
 513 };
 514
 515 #ifdef CONFIG_AC3_DEMUXER
 516 AVInputFormat ac3_demuxer = {
 517     "ac3",
 518     NULL_IF_CONFIG_SMALL("raw AC-3"),
 519     0,
 520     ac3_probe,
 521     audio_read_header,
 522     raw_read_partial_packet,
 523     .flags= AVFMT_GENERIC_INDEX,
 524     .extensions = "ac3",
 525     .value = CODEC_ID_AC3,
 526 };
 527 #endif
 528
 529 #ifdef CONFIG_MUXERS
 530 AVOutputFormat ac3_muxer = {
 531     "ac3",
 532     NULL_IF_CONFIG_SMALL("raw AC-3"),
 533     "audio/x-ac3",
 534     "ac3",
 535     0,
 536     CODEC_ID_AC3,
 537     CODEC_ID_NONE,
 538     NULL,
 539     raw_write_packet,
 540     .flags= AVFMT_NOTIMESTAMPS,
 541 };
 542 #endif //CONFIG_MUXERS
 543
 544 AVInputFormat dirac_demuxer = {
 545     "dirac",
 546     NULL_IF_CONFIG_SMALL("raw Dirac"),
 547     0,
 548     dirac_probe,
 549     video_read_header,
 550     raw_read_partial_packet,
 551     .flags= AVFMT_GENERIC_INDEX,
 552     .value = CODEC_ID_DIRAC,
 553 };
 554
 555 #ifdef CONFIG_MUXERS
 556 AVOutputFormat dirac_muxer = {
 557     "dirac",
 558     NULL_IF_CONFIG_SMALL("raw Dirac"),
 559     NULL,
 560     "drc",
 561     0,
 562     CODEC_ID_NONE,
 563     CODEC_ID_DIRAC,
 564     NULL,
 565     raw_write_packet,
 566     .flags= AVFMT_NOTIMESTAMPS,
 567 };
 568 #endif
 569
 570 AVInputFormat dts_demuxer = {
 571     "dts",
 572     NULL_IF_CONFIG_SMALL("raw DTS"),
 573     0,
 574     dts_probe,
 575     audio_read_header,
 576     raw_read_partial_packet,
 577     .flags= AVFMT_GENERIC_INDEX,
 578     .extensions = "dts",
 579     .value = CODEC_ID_DTS,
 580 };
 581
 582 #ifdef CONFIG_MUXERS
 583 AVOutputFormat dts_muxer = {
 584     "dts",
 585     NULL_IF_CONFIG_SMALL("raw DTS"),
 586     "audio/x-dca",
 587     "dts",
 588     0,
 589     CODEC_ID_DTS,
 590     CODEC_ID_NONE,
 591     NULL,
 592     raw_write_packet,
 593     .flags= AVFMT_NOTIMESTAMPS,
 594 };
 595 #endif
 596
 597 AVInputFormat flac_demuxer = {
 598     "flac",
 599     NULL_IF_CONFIG_SMALL("raw FLAC"),
 600     0,
 601     flac_probe,
 602     audio_read_header,
 603     raw_read_partial_packet,
 604     .flags= AVFMT_GENERIC_INDEX,
 605     .extensions = "flac",
 606     .value = CODEC_ID_FLAC,
 607 };
 608
 609 #ifdef CONFIG_MUXERS
 610 AVOutputFormat flac_muxer = {
 611     "flac",
 612     NULL_IF_CONFIG_SMALL("raw FLAC"),
 613     "audio/x-flac",
 614     "flac",
 615     0,
 616     CODEC_ID_FLAC,
 617     CODEC_ID_NONE,
 618     flac_write_header,
 619     raw_write_packet,
 620     .flags= AVFMT_NOTIMESTAMPS,
 621 };
 622 #endif //CONFIG_MUXERS
 623
 624 AVInputFormat gsm_demuxer = {
 625     "gsm",
 626     NULL_IF_CONFIG_SMALL("GSM"),
 627     0,
 628     NULL,
 629     audio_read_header,
 630     raw_read_partial_packet,
 631     .flags= AVFMT_GENERIC_INDEX,
 632     .extensions = "gsm",
 633     .value = CODEC_ID_GSM,
 634 };
 635
 636 AVInputFormat h261_demuxer = {
 637     "h261",
 638     NULL_IF_CONFIG_SMALL("raw H.261"),
 639     0,
 640     h261_probe,
 641     video_read_header,
 642     raw_read_partial_packet,
 643     .flags= AVFMT_GENERIC_INDEX,
 644     .extensions = "h261",
 645     .value = CODEC_ID_H261,
 646 };
 647
 648 #ifdef CONFIG_MUXERS
 649 AVOutputFormat h261_muxer = {
 650     "h261",
 651     NULL_IF_CONFIG_SMALL("raw H.261"),
 652     "video/x-h261",
 653     "h261",
 654     0,
 655     CODEC_ID_NONE,
 656     CODEC_ID_H261,
 657     NULL,
 658     raw_write_packet,
 659     .flags= AVFMT_NOTIMESTAMPS,
 660 };
 661 #endif //CONFIG_MUXERS
 662
 663 AVInputFormat h263_demuxer = {
 664     "h263",
 665     NULL_IF_CONFIG_SMALL("raw H.263"),
 666     0,
 667     h263_probe,
 668     video_read_header,
 669     raw_read_partial_packet,
 670     .flags= AVFMT_GENERIC_INDEX,
 671 //    .extensions = "h263", //FIXME remove after writing mpeg4_probe
 672     .value = CODEC_ID_H263,
 673 };
 674
 675 #ifdef CONFIG_MUXERS
 676 AVOutputFormat h263_muxer = {
 677     "h263",
 678     NULL_IF_CONFIG_SMALL("raw H.263"),
 679     "video/x-h263",
 680     "h263",
 681     0,
 682     CODEC_ID_NONE,
 683     CODEC_ID_H263,
 684     NULL,
 685     raw_write_packet,
 686     .flags= AVFMT_NOTIMESTAMPS,
 687 };
 688 #endif //CONFIG_MUXERS
 689
 690 AVInputFormat h264_demuxer = {
 691     "h264",
 692     NULL_IF_CONFIG_SMALL("raw H.264 video format"),
 693     0,
 694     h264_probe,
 695     video_read_header,
 696     raw_read_partial_packet,
 697     .flags= AVFMT_GENERIC_INDEX,
 698     .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
 699     .value = CODEC_ID_H264,
 700 };
 701
 702 #ifdef CONFIG_MUXERS
 703 AVOutputFormat h264_muxer = {
 704     "h264",
 705     NULL_IF_CONFIG_SMALL("raw H.264 video format"),
 706     NULL,
 707     "h264",
 708     0,
 709     CODEC_ID_NONE,
 710     CODEC_ID_H264,
 711     NULL,
 712     raw_write_packet,
 713     .flags= AVFMT_NOTIMESTAMPS,
 714 };
 715 #endif //CONFIG_MUXERS
 716
 717 AVInputFormat ingenient_demuxer = {
 718     "ingenient",
 719     NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),
 720     0,
 721     NULL,
 722     video_read_header,
 723     ingenient_read_packet,
 724     .flags= AVFMT_GENERIC_INDEX,
 725     .extensions = "cgi", // FIXME
 726     .value = CODEC_ID_MJPEG,
 727 };
 728
 729 AVInputFormat m4v_demuxer = {
 730     "m4v",
 731     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
 732     0,
 733     mpeg4video_probe, /** probing for mpeg4 data */
 734     video_read_header,
 735     raw_read_partial_packet,
 736     .flags= AVFMT_GENERIC_INDEX,
 737     .extensions = "m4v", //FIXME remove after writing mpeg4_probe
 738     .value = CODEC_ID_MPEG4,
 739 };
 740
 741 #ifdef CONFIG_MUXERS
 742 AVOutputFormat m4v_muxer = {
 743     "m4v",
 744     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
 745     NULL,
 746     "m4v",
 747     0,
 748     CODEC_ID_NONE,
 749     CODEC_ID_MPEG4,
 750     NULL,
 751     raw_write_packet,
 752     .flags= AVFMT_NOTIMESTAMPS,
 753 };
 754 #endif //CONFIG_MUXERS
 755
 756 AVInputFormat mjpeg_demuxer = {
 757     "mjpeg",
 758     NULL_IF_CONFIG_SMALL("MJPEG video"),
 759     0,
 760     NULL,
 761     video_read_header,
 762     raw_read_partial_packet,
 763     .flags= AVFMT_GENERIC_INDEX,
 764     .extensions = "mjpg,mjpeg",
 765     .value = CODEC_ID_MJPEG,
 766 };
 767
 768 #ifdef CONFIG_MUXERS
 769 AVOutputFormat mjpeg_muxer = {
 770     "mjpeg",
 771     NULL_IF_CONFIG_SMALL("MJPEG video"),
 772     "video/x-mjpeg",
 773     "mjpg,mjpeg",
 774     0,
 775     CODEC_ID_NONE,
 776     CODEC_ID_MJPEG,
 777     NULL,
 778     raw_write_packet,
 779     .flags= AVFMT_NOTIMESTAMPS,
 780 };
 781 #endif //CONFIG_MUXERS
 782
 783 AVInputFormat mlp_demuxer = {
 784     "mlp",
 785     NULL_IF_CONFIG_SMALL("raw MLP"),
 786     0,
 787     NULL,
 788     audio_read_header,
 789     raw_read_partial_packet,
 790     .flags= AVFMT_GENERIC_INDEX,
 791     .extensions = "mlp",
 792     .value = CODEC_ID_MLP,
 793 };
 794
 795 #ifdef CONFIG_MUXERS
 796 AVOutputFormat mpeg1video_muxer = {
 797     "mpeg1video",
 798     NULL_IF_CONFIG_SMALL("MPEG video"),
 799     "video/x-mpeg",
 800     "mpg,mpeg,m1v",
 801     0,
 802     CODEC_ID_NONE,
 803     CODEC_ID_MPEG1VIDEO,
 804     NULL,
 805     raw_write_packet,
 806     .flags= AVFMT_NOTIMESTAMPS,
 807 };
 808 #endif //CONFIG_MUXERS
 809
 810 #ifdef CONFIG_MUXERS
 811 AVOutputFormat mpeg2video_muxer = {
 812     "mpeg2video",
 813     NULL_IF_CONFIG_SMALL("MPEG-2 video"),
 814     NULL,
 815     "m2v",
 816     0,
 817     CODEC_ID_NONE,
 818     CODEC_ID_MPEG2VIDEO,
 819     NULL,
 820     raw_write_packet,
 821     .flags= AVFMT_NOTIMESTAMPS,
 822 };
 823 #endif //CONFIG_MUXERS
 824
 825 AVInputFormat mpegvideo_demuxer = {
 826     "mpegvideo",
 827     NULL_IF_CONFIG_SMALL("MPEG video"),
 828     0,
 829     mpegvideo_probe,
 830     video_read_header,
 831     raw_read_partial_packet,
 832     .flags= AVFMT_GENERIC_INDEX,
 833     .value = CODEC_ID_MPEG1VIDEO,
 834 };
 835
 836 #ifdef CONFIG_MUXERS
 837 AVOutputFormat null_muxer = {
 838     "null",
 839     NULL_IF_CONFIG_SMALL("null video format"),
 840     NULL,
 841     NULL,
 842     0,
 843 #ifdef WORDS_BIGENDIAN
 844     CODEC_ID_PCM_S16BE,
 845 #else
 846     CODEC_ID_PCM_S16LE,
 847 #endif
 848     CODEC_ID_RAWVIDEO,
 849     NULL,
 850     null_write_packet,
 851     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
 852 };
 853 #endif //CONFIG_MUXERS
 854
 855 AVInputFormat rawvideo_demuxer = {
 856     "rawvideo",
 857     NULL_IF_CONFIG_SMALL("raw video format"),
 858     0,
 859     NULL,
 860     raw_read_header,
 861     rawvideo_read_packet,
 862     .flags= AVFMT_GENERIC_INDEX,
 863     .extensions = "yuv,cif,qcif,rgb",
 864     .value = CODEC_ID_RAWVIDEO,
 865 };
 866
 867 #ifdef CONFIG_MUXERS
 868 AVOutputFormat rawvideo_muxer = {
 869     "rawvideo",
 870     NULL_IF_CONFIG_SMALL("raw video format"),
 871     NULL,
 872     "yuv,rgb",
 873     0,
 874     CODEC_ID_NONE,
 875     CODEC_ID_RAWVIDEO,
 876     NULL,
 877     raw_write_packet,
 878     .flags= AVFMT_NOTIMESTAMPS,
 879 };
 880 #endif //CONFIG_MUXERS
 881
 882 #ifdef CONFIG_ROQ_MUXER
 883 AVOutputFormat roq_muxer =
 884 {
 885     "RoQ",
 886     NULL_IF_CONFIG_SMALL("id RoQ format"),
 887     NULL,
 888     "roq",
 889     0,
 890     CODEC_ID_ROQ_DPCM,
 891     CODEC_ID_ROQ,
 892     roq_write_header,
 893     raw_write_packet,
 894 };
 895 #endif //CONFIG_ROQ_MUXER
 896
 897 AVInputFormat shorten_demuxer = {
 898     "shn",
 899     NULL_IF_CONFIG_SMALL("raw Shorten"),
 900     0,
 901     NULL,
 902     audio_read_header,
 903     raw_read_partial_packet,
 904     .flags= AVFMT_GENERIC_INDEX,
 905     .extensions = "shn",
 906     .value = CODEC_ID_SHORTEN,
 907 };
 908
 909 AVInputFormat vc1_demuxer = {
 910     "vc1",
 911     NULL_IF_CONFIG_SMALL("raw VC-1"),
 912     0,
 913     NULL /* vc1_probe */,
 914     video_read_header,
 915     raw_read_partial_packet,
 916     .extensions = "vc1",
 917     .value = CODEC_ID_VC1,
 918 };
 919
 920 /* pcm formats */
 921
 922 #define PCMINPUTDEF(name, long_name, ext, codec) \
 923 AVInputFormat pcm_ ## name ## _demuxer = {\
 924     #name,\
 925     NULL_IF_CONFIG_SMALL(long_name),\
 926     0,\
 927     NULL,\
 928     raw_read_header,\
 929     raw_read_packet,\
 930     NULL,\
 931     pcm_read_seek,\
 932     .flags= AVFMT_GENERIC_INDEX,\
 933     .extensions = ext,\
 934     .value = codec,\
 935 };
 936
 937 #define PCMOUTPUTDEF(name, long_name, ext, codec) \
 938 AVOutputFormat pcm_ ## name ## _muxer = {\
 939     #name,\
 940     NULL_IF_CONFIG_SMALL(long_name),\
 941     NULL,\
 942     ext,\
 943     0,\
 944     codec,\
 945     CODEC_ID_NONE,\
 946     NULL,\
 947     raw_write_packet,\
 948     .flags= AVFMT_NOTIMESTAMPS,\
 949 };
 950
 951
 952 #if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
 953 #define PCMDEF(name, long_name, ext, codec) \
 954         PCMINPUTDEF(name, long_name, ext, codec)
 955 #elif defined(CONFIG_MUXERS) && !defined(CONFIG_DEMUXERS)
 956 #define PCMDEF(name, long_name, ext, codec) \
 957         PCMOUTPUTDEF(name, long_name, ext, codec)
 958 #elif defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
 959 #define PCMDEF(name, long_name, ext, codec) \
 960         PCMINPUTDEF(name, long_name, ext, codec)\
 961         PCMOUTPUTDEF(name, long_name, ext, codec)
 962 #else
 963 #define PCMDEF(name, long_name, ext, codec)
 964 #endif
 965
 966 #ifdef WORDS_BIGENDIAN
 967 #define BE_DEF(s) s
 968 #define LE_DEF(s) NULL
 969 #else
 970 #define BE_DEF(s) NULL
 971 #define LE_DEF(s) s
 972 #endif
 973
 974
 975 PCMDEF(s16be, "PCM signed 16 bit big-endian format",
 976        BE_DEF("sw"), CODEC_ID_PCM_S16BE)
 977
 978 PCMDEF(s16le, "PCM signed 16 bit little-endian format",
 979        LE_DEF("sw"), CODEC_ID_PCM_S16LE)
 980
 981 PCMDEF(s8, "PCM signed 8 bit format",
 982        "sb", CODEC_ID_PCM_S8)
 983
 984 PCMDEF(u16be, "PCM unsigned 16 bit big-endian format",
 985        BE_DEF("uw"), CODEC_ID_PCM_U16BE)
 986
 987 PCMDEF(u16le, "PCM unsigned 16 bit little-endian format",
 988        LE_DEF("uw"), CODEC_ID_PCM_U16LE)
 989
 990 PCMDEF(u8, "PCM unsigned 8 bit format",
 991        "ub", CODEC_ID_PCM_U8)
 992
 993 PCMDEF(alaw, "PCM A-law format",
 994        "al", CODEC_ID_PCM_ALAW)
 995
 996 PCMDEF(mulaw, "PCM mu-law format",
 997        "ul", CODEC_ID_PCM_MULAW)