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