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