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, ret;
 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     if ((ret = url_fseek(s->pb, pos + s->data_offset, SEEK_SET)) < 0)
 247         return ret;
 248     return 0;
 249 }
 250
 251 static int audio_read_header(AVFormatContext *s,
 252                              AVFormatParameters *ap)
 253 {
 254     AVStream *st = av_new_stream(s, 0);
 255     if (!st)
 256         return AVERROR(ENOMEM);
 257     st->codec->codec_type = CODEC_TYPE_AUDIO;
 258     st->codec->codec_id = s->iformat->value;
 259     st->need_parsing = AVSTREAM_PARSE_FULL;
 260     /* the parameters will be extracted from the compressed bitstream */
 261     return 0;
 262 }
 263
 264 /* mpeg1/h263 input */
 265 static int video_read_header(AVFormatContext *s,
 266                              AVFormatParameters *ap)
 267 {
 268     AVStream *st;
 269
 270     st = av_new_stream(s, 0);
 271     if (!st)
 272         return AVERROR(ENOMEM);
 273
 274     st->codec->codec_type = CODEC_TYPE_VIDEO;
 275     st->codec->codec_id = s->iformat->value;
 276     st->need_parsing = AVSTREAM_PARSE_FULL;
 277
 278     /* for mjpeg, specify frame rate */
 279     /* for mpeg4 specify it too (most mpeg4 streams do not have the fixed_vop_rate set ...)*/
 280     if (ap->time_base.num) {
 281         av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
 282     } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
 283                 st->codec->codec_id == CODEC_ID_MPEG4 ||
 284                 st->codec->codec_id == CODEC_ID_DIRAC ||
 285                 st->codec->codec_id == CODEC_ID_H264) {
 286         av_set_pts_info(st, 64, 1, 25);
 287     }
 288
 289     return 0;
 290 }
 291
 292 #define SEQ_START_CODE          0x000001b3
 293 #define GOP_START_CODE          0x000001b8
 294 #define PICTURE_START_CODE      0x00000100
 295 #define SLICE_START_CODE        0x00000101
 296 #define PACK_START_CODE         0x000001ba
 297 #define VIDEO_ID                0x000001e0
 298 #define AUDIO_ID                0x000001c0
 299
 300 static int mpegvideo_probe(AVProbeData *p)
 301 {
 302     uint32_t code= -1;
 303     int pic=0, seq=0, slice=0, pspack=0, pes=0;
 304     int i;
 305
 306     for(i=0; i<p->buf_size; i++){
 307         code = (code<<8) + p->buf[i];
 308         if ((code & 0xffffff00) == 0x100) {
 309             switch(code){
 310             case     SEQ_START_CODE:   seq++; break;
 311             case PICTURE_START_CODE:   pic++; break;
 312             case   SLICE_START_CODE: slice++; break;
 313             case    PACK_START_CODE: pspack++; break;
 314             }
 315             if     ((code & 0x1f0) == VIDEO_ID)   pes++;
 316             else if((code & 0x1e0) == AUDIO_ID)   pes++;
 317         }
 318     }
 319     if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)
 320         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
 321     return 0;
 322 }
 323
 324 #define VISUAL_OBJECT_START_CODE       0x000001b5
 325 #define VOP_START_CODE                 0x000001b6
 326
 327 static int mpeg4video_probe(AVProbeData *probe_packet)
 328 {
 329     uint32_t temp_buffer= -1;
 330     int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;
 331     int i;
 332
 333     for(i=0; i<probe_packet->buf_size; i++){
 334         temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];
 335         if ((temp_buffer & 0xffffff00) != 0x100)
 336             continue;
 337
 338         if (temp_buffer == VOP_START_CODE)                         VOP++;
 339         else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;
 340         else if (temp_buffer < 0x120)                              VO++;
 341         else if (temp_buffer < 0x130)                              VOL++;
 342         else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)
 343                  && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;
 344     }
 345
 346     if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)
 347         return AVPROBE_SCORE_MAX/2;
 348     return 0;
 349 }
 350
 351 static int h264_probe(AVProbeData *p)
 352 {
 353     uint32_t code= -1;
 354     int sps=0, pps=0, idr=0, res=0, sli=0;
 355     int i;
 356
 357     for(i=0; i<p->buf_size; i++){
 358         code = (code<<8) + p->buf[i];
 359         if ((code & 0xffffff00) == 0x100) {
 360             int ref_idc= (code>>5)&3;
 361             int type   = code & 0x1F;
 362             static const int8_t ref_zero[32]={
 363                 2, 0, 0, 0, 0,-1, 1,-1,
 364                -1, 1, 1, 1, 1,-1, 2, 2,
 365                 2, 2, 2, 0, 2, 2, 2, 2,
 366                 2, 2, 2, 2, 2, 2, 2, 2
 367             };
 368
 369             if(code & 0x80) //forbidden bit
 370                 return 0;
 371
 372             if(ref_zero[type] == 1 && ref_idc)
 373                 return 0;
 374             if(ref_zero[type] ==-1 && !ref_idc)
 375                 return 0;
 376             if(ref_zero[type] == 2)
 377                 res++;
 378
 379             switch(type){
 380             case     1:   sli++; break;
 381             case     5:   idr++; break;
 382             case     7:
 383                 if(p->buf[i+2]&0x0F)
 384                     return 0;
 385                 sps++;
 386                 break;
 387             case     8:   pps++; break;
 388             }
 389         }
 390     }
 391     if(sps && pps && (idr||sli>3) && res<(sps+pps+idr))
 392         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
 393     return 0;
 394 }
 395
 396 static int h263_probe(AVProbeData *p)
 397 {
 398     int code;
 399     const uint8_t *d;
 400
 401     d = p->buf;
 402     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
 403     if (code == 0x20) {
 404         return 50;
 405     }
 406     return 0;
 407 }
 408
 409 static int h261_probe(AVProbeData *p)
 410 {
 411     int code;
 412     const uint8_t *d;
 413
 414     d = p->buf;
 415     code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
 416     if (code == 0x10) {
 417         return 50;
 418     }
 419     return 0;
 420 }
 421
 422 #define DCA_MARKER_14B_BE 0x1FFFE800
 423 #define DCA_MARKER_14B_LE 0xFF1F00E8
 424 #define DCA_MARKER_RAW_BE 0x7FFE8001
 425 #define DCA_MARKER_RAW_LE 0xFE7F0180
 426 static int dts_probe(AVProbeData *p)
 427 {
 428     const uint8_t *buf, *bufp;
 429     uint32_t state = -1;
 430
 431     buf = p->buf;
 432
 433     for(; buf < (p->buf+p->buf_size)-2; buf+=2) {
 434         bufp = buf;
 435         state = (state << 16) | bytestream_get_be16(&bufp);
 436
 437         /* Regular bitstream */
 438         if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)
 439             return AVPROBE_SCORE_MAX/2+1;
 440
 441         /* 14 bits big endian bitstream */
 442         if (state == DCA_MARKER_14B_BE)
 443             if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)
 444                 return AVPROBE_SCORE_MAX/2+1;
 445
 446         /* 14 bits little endian bitstream */
 447         if (state == DCA_MARKER_14B_LE)
 448             if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)
 449                 return AVPROBE_SCORE_MAX/2+1;
 450     }
 451
 452     return 0;
 453 }
 454
 455 static int dirac_probe(AVProbeData *p)
 456 {
 457     if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
 458         return AVPROBE_SCORE_MAX;
 459     else
 460         return 0;
 461 }
 462
 463 static int ac3_probe(AVProbeData *p)
 464 {
 465     int max_frames, first_frames = 0, frames;
 466     uint8_t *buf, *buf2, *end;
 467     AC3HeaderInfo hdr;
 468     GetBitContext gbc;
 469
 470     max_frames = 0;
 471     buf = p->buf;
 472     end = buf + p->buf_size;
 473
 474     for(; buf < end; buf++) {
 475         buf2 = buf;
 476
 477         for(frames = 0; buf2 < end; frames++) {
 478             init_get_bits(&gbc, buf2, 54);
 479             if(ff_ac3_parse_header(&gbc, &hdr) < 0)
 480                 break;
 481             if(buf2 + hdr.frame_size > end ||
 482                av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))
 483                 break;
 484             buf2 += hdr.frame_size;
 485         }
 486         max_frames = FFMAX(max_frames, frames);
 487         if(buf == p->buf)
 488             first_frames = frames;
 489     }
 490     if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
 491     else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
 492     else if(max_frames>=1) return 1;
 493     else                   return 0;
 494 }
 495
 496 static int flac_probe(AVProbeData *p)
 497 {
 498     if(memcmp(p->buf, "fLaC", 4)) return 0;
 499     else                          return AVPROBE_SCORE_MAX / 2;
 500 }
 501
 502
 503 /* Note: Do not forget to add new entries to the Makefile as well. */
 504
 505 AVInputFormat aac_demuxer = {
 506     "aac",
 507     NULL_IF_CONFIG_SMALL("ADTS AAC"),
 508     0,
 509     NULL,
 510     audio_read_header,
 511     raw_read_partial_packet,
 512     .flags= AVFMT_GENERIC_INDEX,
 513     .extensions = "aac",
 514     .value = CODEC_ID_AAC,
 515 };
 516
 517 #ifdef CONFIG_AC3_DEMUXER
 518 AVInputFormat ac3_demuxer = {
 519     "ac3",
 520     NULL_IF_CONFIG_SMALL("raw AC-3"),
 521     0,
 522     ac3_probe,
 523     audio_read_header,
 524     raw_read_partial_packet,
 525     .flags= AVFMT_GENERIC_INDEX,
 526     .extensions = "ac3",
 527     .value = CODEC_ID_AC3,
 528 };
 529 #endif
 530
 531 #ifdef CONFIG_MUXERS
 532 AVOutputFormat ac3_muxer = {
 533     "ac3",
 534     NULL_IF_CONFIG_SMALL("raw AC-3"),
 535     "audio/x-ac3",
 536     "ac3",
 537     0,
 538     CODEC_ID_AC3,
 539     CODEC_ID_NONE,
 540     NULL,
 541     raw_write_packet,
 542     .flags= AVFMT_NOTIMESTAMPS,
 543 };
 544 #endif //CONFIG_MUXERS
 545
 546 AVInputFormat dirac_demuxer = {
 547     "dirac",
 548     NULL_IF_CONFIG_SMALL("raw Dirac"),
 549     0,
 550     dirac_probe,
 551     video_read_header,
 552     raw_read_partial_packet,
 553     .flags= AVFMT_GENERIC_INDEX,
 554     .value = CODEC_ID_DIRAC,
 555 };
 556
 557 #ifdef CONFIG_MUXERS
 558 AVOutputFormat dirac_muxer = {
 559     "dirac",
 560     NULL_IF_CONFIG_SMALL("raw Dirac"),
 561     NULL,
 562     "drc",
 563     0,
 564     CODEC_ID_NONE,
 565     CODEC_ID_DIRAC,
 566     NULL,
 567     raw_write_packet,
 568     .flags= AVFMT_NOTIMESTAMPS,
 569 };
 570 #endif
 571
 572 AVInputFormat dts_demuxer = {
 573     "dts",
 574     NULL_IF_CONFIG_SMALL("raw DTS"),
 575     0,
 576     dts_probe,
 577     audio_read_header,
 578     raw_read_partial_packet,
 579     .flags= AVFMT_GENERIC_INDEX,
 580     .extensions = "dts",
 581     .value = CODEC_ID_DTS,
 582 };
 583
 584 #ifdef CONFIG_MUXERS
 585 AVOutputFormat dts_muxer = {
 586     "dts",
 587     NULL_IF_CONFIG_SMALL("raw DTS"),
 588     "audio/x-dca",
 589     "dts",
 590     0,
 591     CODEC_ID_DTS,
 592     CODEC_ID_NONE,
 593     NULL,
 594     raw_write_packet,
 595     .flags= AVFMT_NOTIMESTAMPS,
 596 };
 597 #endif
 598
 599 AVInputFormat flac_demuxer = {
 600     "flac",
 601     NULL_IF_CONFIG_SMALL("raw FLAC"),
 602     0,
 603     flac_probe,
 604     audio_read_header,
 605     raw_read_partial_packet,
 606     .flags= AVFMT_GENERIC_INDEX,
 607     .extensions = "flac",
 608     .value = CODEC_ID_FLAC,
 609 };
 610
 611 #ifdef CONFIG_MUXERS
 612 AVOutputFormat flac_muxer = {
 613     "flac",
 614     NULL_IF_CONFIG_SMALL("raw FLAC"),
 615     "audio/x-flac",
 616     "flac",
 617     0,
 618     CODEC_ID_FLAC,
 619     CODEC_ID_NONE,
 620     flac_write_header,
 621     raw_write_packet,
 622     .flags= AVFMT_NOTIMESTAMPS,
 623 };
 624 #endif //CONFIG_MUXERS
 625
 626 AVInputFormat gsm_demuxer = {
 627     "gsm",
 628     NULL_IF_CONFIG_SMALL("GSM"),
 629     0,
 630     NULL,
 631     audio_read_header,
 632     raw_read_partial_packet,
 633     .flags= AVFMT_GENERIC_INDEX,
 634     .extensions = "gsm",
 635     .value = CODEC_ID_GSM,
 636 };
 637
 638 AVInputFormat h261_demuxer = {
 639     "h261",
 640     NULL_IF_CONFIG_SMALL("raw H.261"),
 641     0,
 642     h261_probe,
 643     video_read_header,
 644     raw_read_partial_packet,
 645     .flags= AVFMT_GENERIC_INDEX,
 646     .extensions = "h261",
 647     .value = CODEC_ID_H261,
 648 };
 649
 650 #ifdef CONFIG_MUXERS
 651 AVOutputFormat h261_muxer = {
 652     "h261",
 653     NULL_IF_CONFIG_SMALL("raw H.261"),
 654     "video/x-h261",
 655     "h261",
 656     0,
 657     CODEC_ID_NONE,
 658     CODEC_ID_H261,
 659     NULL,
 660     raw_write_packet,
 661     .flags= AVFMT_NOTIMESTAMPS,
 662 };
 663 #endif //CONFIG_MUXERS
 664
 665 AVInputFormat h263_demuxer = {
 666     "h263",
 667     NULL_IF_CONFIG_SMALL("raw H.263"),
 668     0,
 669     h263_probe,
 670     video_read_header,
 671     raw_read_partial_packet,
 672     .flags= AVFMT_GENERIC_INDEX,
 673 //    .extensions = "h263", //FIXME remove after writing mpeg4_probe
 674     .value = CODEC_ID_H263,
 675 };
 676
 677 #ifdef CONFIG_MUXERS
 678 AVOutputFormat h263_muxer = {
 679     "h263",
 680     NULL_IF_CONFIG_SMALL("raw H.263"),
 681     "video/x-h263",
 682     "h263",
 683     0,
 684     CODEC_ID_NONE,
 685     CODEC_ID_H263,
 686     NULL,
 687     raw_write_packet,
 688     .flags= AVFMT_NOTIMESTAMPS,
 689 };
 690 #endif //CONFIG_MUXERS
 691
 692 AVInputFormat h264_demuxer = {
 693     "h264",
 694     NULL_IF_CONFIG_SMALL("raw H.264 video format"),
 695     0,
 696     h264_probe,
 697     video_read_header,
 698     raw_read_partial_packet,
 699     .flags= AVFMT_GENERIC_INDEX,
 700     .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
 701     .value = CODEC_ID_H264,
 702 };
 703
 704 #ifdef CONFIG_MUXERS
 705 AVOutputFormat h264_muxer = {
 706     "h264",
 707     NULL_IF_CONFIG_SMALL("raw H.264 video format"),
 708     NULL,
 709     "h264",
 710     0,
 711     CODEC_ID_NONE,
 712     CODEC_ID_H264,
 713     NULL,
 714     raw_write_packet,
 715     .flags= AVFMT_NOTIMESTAMPS,
 716 };
 717 #endif //CONFIG_MUXERS
 718
 719 AVInputFormat ingenient_demuxer = {
 720     "ingenient",
 721     NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),
 722     0,
 723     NULL,
 724     video_read_header,
 725     ingenient_read_packet,
 726     .flags= AVFMT_GENERIC_INDEX,
 727     .extensions = "cgi", // FIXME
 728     .value = CODEC_ID_MJPEG,
 729 };
 730
 731 AVInputFormat m4v_demuxer = {
 732     "m4v",
 733     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
 734     0,
 735     mpeg4video_probe, /** probing for mpeg4 data */
 736     video_read_header,
 737     raw_read_partial_packet,
 738     .flags= AVFMT_GENERIC_INDEX,
 739     .extensions = "m4v", //FIXME remove after writing mpeg4_probe
 740     .value = CODEC_ID_MPEG4,
 741 };
 742
 743 #ifdef CONFIG_MUXERS
 744 AVOutputFormat m4v_muxer = {
 745     "m4v",
 746     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
 747     NULL,
 748     "m4v",
 749     0,
 750     CODEC_ID_NONE,
 751     CODEC_ID_MPEG4,
 752     NULL,
 753     raw_write_packet,
 754     .flags= AVFMT_NOTIMESTAMPS,
 755 };
 756 #endif //CONFIG_MUXERS
 757
 758 AVInputFormat mjpeg_demuxer = {
 759     "mjpeg",
 760     NULL_IF_CONFIG_SMALL("MJPEG video"),
 761     0,
 762     NULL,
 763     video_read_header,
 764     raw_read_partial_packet,
 765     .flags= AVFMT_GENERIC_INDEX,
 766     .extensions = "mjpg,mjpeg",
 767     .value = CODEC_ID_MJPEG,
 768 };
 769
 770 #ifdef CONFIG_MUXERS
 771 AVOutputFormat mjpeg_muxer = {
 772     "mjpeg",
 773     NULL_IF_CONFIG_SMALL("MJPEG video"),
 774     "video/x-mjpeg",
 775     "mjpg,mjpeg",
 776     0,
 777     CODEC_ID_NONE,
 778     CODEC_ID_MJPEG,
 779     NULL,
 780     raw_write_packet,
 781     .flags= AVFMT_NOTIMESTAMPS,
 782 };
 783 #endif //CONFIG_MUXERS
 784
 785 AVInputFormat mlp_demuxer = {
 786     "mlp",
 787     NULL_IF_CONFIG_SMALL("raw MLP"),
 788     0,
 789     NULL,
 790     audio_read_header,
 791     raw_read_partial_packet,
 792     .flags= AVFMT_GENERIC_INDEX,
 793     .extensions = "mlp",
 794     .value = CODEC_ID_MLP,
 795 };
 796
 797 #ifdef CONFIG_MUXERS
 798 AVOutputFormat mpeg1video_muxer = {
 799     "mpeg1video",
 800     NULL_IF_CONFIG_SMALL("MPEG video"),
 801     "video/x-mpeg",
 802     "mpg,mpeg,m1v",
 803     0,
 804     CODEC_ID_NONE,
 805     CODEC_ID_MPEG1VIDEO,
 806     NULL,
 807     raw_write_packet,
 808     .flags= AVFMT_NOTIMESTAMPS,
 809 };
 810 #endif //CONFIG_MUXERS
 811
 812 #ifdef CONFIG_MUXERS
 813 AVOutputFormat mpeg2video_muxer = {
 814     "mpeg2video",
 815     NULL_IF_CONFIG_SMALL("MPEG-2 video"),
 816     NULL,
 817     "m2v",
 818     0,
 819     CODEC_ID_NONE,
 820     CODEC_ID_MPEG2VIDEO,
 821     NULL,
 822     raw_write_packet,
 823     .flags= AVFMT_NOTIMESTAMPS,
 824 };
 825 #endif //CONFIG_MUXERS
 826
 827 AVInputFormat mpegvideo_demuxer = {
 828     "mpegvideo",
 829     NULL_IF_CONFIG_SMALL("MPEG video"),
 830     0,
 831     mpegvideo_probe,
 832     video_read_header,
 833     raw_read_partial_packet,
 834     .flags= AVFMT_GENERIC_INDEX,
 835     .value = CODEC_ID_MPEG1VIDEO,
 836 };
 837
 838 #ifdef CONFIG_MUXERS
 839 AVOutputFormat null_muxer = {
 840     "null",
 841     NULL_IF_CONFIG_SMALL("null video format"),
 842     NULL,
 843     NULL,
 844     0,
 845 #ifdef WORDS_BIGENDIAN
 846     CODEC_ID_PCM_S16BE,
 847 #else
 848     CODEC_ID_PCM_S16LE,
 849 #endif
 850     CODEC_ID_RAWVIDEO,
 851     NULL,
 852     null_write_packet,
 853     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
 854 };
 855 #endif //CONFIG_MUXERS
 856
 857 AVInputFormat rawvideo_demuxer = {
 858     "rawvideo",
 859     NULL_IF_CONFIG_SMALL("raw video format"),
 860     0,
 861     NULL,
 862     raw_read_header,
 863     rawvideo_read_packet,
 864     .flags= AVFMT_GENERIC_INDEX,
 865     .extensions = "yuv,cif,qcif,rgb",
 866     .value = CODEC_ID_RAWVIDEO,
 867 };
 868
 869 #ifdef CONFIG_MUXERS
 870 AVOutputFormat rawvideo_muxer = {
 871     "rawvideo",
 872     NULL_IF_CONFIG_SMALL("raw video format"),
 873     NULL,
 874     "yuv,rgb",
 875     0,
 876     CODEC_ID_NONE,
 877     CODEC_ID_RAWVIDEO,
 878     NULL,
 879     raw_write_packet,
 880     .flags= AVFMT_NOTIMESTAMPS,
 881 };
 882 #endif //CONFIG_MUXERS
 883
 884 #ifdef CONFIG_ROQ_MUXER
 885 AVOutputFormat roq_muxer =
 886 {
 887     "RoQ",
 888     NULL_IF_CONFIG_SMALL("id RoQ format"),
 889     NULL,
 890     "roq",
 891     0,
 892     CODEC_ID_ROQ_DPCM,
 893     CODEC_ID_ROQ,
 894     roq_write_header,
 895     raw_write_packet,
 896 };
 897 #endif //CONFIG_ROQ_MUXER
 898
 899 AVInputFormat shorten_demuxer = {
 900     "shn",
 901     NULL_IF_CONFIG_SMALL("raw Shorten"),
 902     0,
 903     NULL,
 904     audio_read_header,
 905     raw_read_partial_packet,
 906     .flags= AVFMT_GENERIC_INDEX,
 907     .extensions = "shn",
 908     .value = CODEC_ID_SHORTEN,
 909 };
 910
 911 AVInputFormat vc1_demuxer = {
 912     "vc1",
 913     NULL_IF_CONFIG_SMALL("raw VC-1"),
 914     0,
 915     NULL /* vc1_probe */,
 916     video_read_header,
 917     raw_read_partial_packet,
 918     .extensions = "vc1",
 919     .value = CODEC_ID_VC1,
 920 };
 921
 922 /* pcm formats */
 923
 924 #define PCMINPUTDEF(name, long_name, ext, codec) \
 925 AVInputFormat pcm_ ## name ## _demuxer = {\
 926     #name,\
 927     NULL_IF_CONFIG_SMALL(long_name),\
 928     0,\
 929     NULL,\
 930     raw_read_header,\
 931     raw_read_packet,\
 932     NULL,\
 933     pcm_read_seek,\
 934     .flags= AVFMT_GENERIC_INDEX,\
 935     .extensions = ext,\
 936     .value = codec,\
 937 };
 938
 939 #define PCMOUTPUTDEF(name, long_name, ext, codec) \
 940 AVOutputFormat pcm_ ## name ## _muxer = {\
 941     #name,\
 942     NULL_IF_CONFIG_SMALL(long_name),\
 943     NULL,\
 944     ext,\
 945     0,\
 946     codec,\
 947     CODEC_ID_NONE,\
 948     NULL,\
 949     raw_write_packet,\
 950     .flags= AVFMT_NOTIMESTAMPS,\
 951 };
 952
 953
 954 #if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
 955 #define PCMDEF(name, long_name, ext, codec) \
 956         PCMINPUTDEF(name, long_name, ext, codec)
 957 #elif defined(CONFIG_MUXERS) && !defined(CONFIG_DEMUXERS)
 958 #define PCMDEF(name, long_name, ext, codec) \
 959         PCMOUTPUTDEF(name, long_name, ext, codec)
 960 #elif defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
 961 #define PCMDEF(name, long_name, ext, codec) \
 962         PCMINPUTDEF(name, long_name, ext, codec)\
 963         PCMOUTPUTDEF(name, long_name, ext, codec)
 964 #else
 965 #define PCMDEF(name, long_name, ext, codec)
 966 #endif
 967
 968 #ifdef WORDS_BIGENDIAN
 969 #define BE_DEF(s) s
 970 #define LE_DEF(s) NULL
 971 #else
 972 #define BE_DEF(s) NULL
 973 #define LE_DEF(s) s
 974 #endif
 975
 976
 977 PCMDEF(s16be, "PCM signed 16 bit big-endian format",
 978        BE_DEF("sw"), CODEC_ID_PCM_S16BE)
 979
 980 PCMDEF(s16le, "PCM signed 16 bit little-endian format",
 981        LE_DEF("sw"), CODEC_ID_PCM_S16LE)
 982
 983 PCMDEF(s8, "PCM signed 8 bit format",
 984        "sb", CODEC_ID_PCM_S8)
 985
 986 PCMDEF(u16be, "PCM unsigned 16 bit big-endian format",
 987        BE_DEF("uw"), CODEC_ID_PCM_U16BE)
 988
 989 PCMDEF(u16le, "PCM unsigned 16 bit little-endian format",
 990        LE_DEF("uw"), CODEC_ID_PCM_U16LE)
 991
 992 PCMDEF(u8, "PCM unsigned 8 bit format",
 993        "ub", CODEC_ID_PCM_U8)
 994
 995 PCMDEF(alaw, "PCM A-law format",
 996        "al", CODEC_ID_PCM_ALAW)
 997
 998 PCMDEF(mulaw, "PCM mu-law format",
 999        "ul", CODEC_ID_PCM_MULAW)