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