falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
14204 Commits
32 Branches
283MB
Tree: 831ec93567
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '831ec93567'
${ noResults }
FFmpeg/libavformat/raw.c

972 lines
23KB
Raw Blame History 

  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 raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)

  60. {

  61.     put_buffer(s->pb, pkt->data, pkt->size);

  62.     put_flush_packet(s->pb);

  63.     return 0;

  64. }

  65. #endif //CONFIG_MUXERS

  66. 

  67. /* raw input */

  68. static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)

  69. {

  70.     AVStream *st;

  71.     int id;

  72. 

  73.     st = av_new_stream(s, 0);

  74.     if (!st)

  75.         return AVERROR(ENOMEM);

  76. 

  77.         id = s->iformat->value;

  78.         if (id == CODEC_ID_RAWVIDEO) {

  79.             st->codec->codec_type = CODEC_TYPE_VIDEO;

  80.         } else {

  81.             st->codec->codec_type = CODEC_TYPE_AUDIO;

  82.         }

  83.         st->codec->codec_id = id;

  84. 

  85.         switch(st->codec->codec_type) {

  86.         case CODEC_TYPE_AUDIO:

  87.             st->codec->sample_rate = ap->sample_rate;

  88.             st->codec->channels = ap->channels;

  89.             av_set_pts_info(st, 64, 1, st->codec->sample_rate);

  90.             break;

  91.         case CODEC_TYPE_VIDEO:

  92.             if(ap->time_base.num)

  93.                 av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);

  94.             else

  95.                 av_set_pts_info(st, 64, 1, 25);

  96.             st->codec->width = ap->width;

  97.             st->codec->height = ap->height;

  98.             st->codec->pix_fmt = ap->pix_fmt;

  99.             if(st->codec->pix_fmt == PIX_FMT_NONE)

  100.                 st->codec->pix_fmt= PIX_FMT_YUV420P;

  101.             break;

  102.         default:

  103.             return -1;

  104.         }

  105.     return 0;

  106. }

  107. 

  108. #define RAW_PACKET_SIZE 1024

  109. 

  110. static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)

  111. {

  112.     int ret, size, bps;

  113.     //    AVStream *st = s->streams[0];

  114. 

  115.     size= RAW_PACKET_SIZE;

  116. 

  117.     ret= av_get_packet(s->pb, pkt, size);

  118. 

  119.     pkt->stream_index = 0;

  120.     if (ret <= 0) {

  121.         return AVERROR(EIO);

  122.     }

  123.     /* note: we need to modify the packet size here to handle the last

  124.        packet */

  125.     pkt->size = ret;

  126. 

  127.     bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id);

  128.     assert(bps); // if false there IS a bug elsewhere (NOT in this function)

  129.     pkt->dts=

  130.     pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels);

  131. 

  132.     return ret;

  133. }

  134. 

  135. static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)

  136. {

  137.     int ret, size;

  138. 

  139.     size = RAW_PACKET_SIZE;

  140. 

  141.     if (av_new_packet(pkt, size) < 0)

  142.         return AVERROR(EIO);

  143. 

  144.     pkt->pos= url_ftell(s->pb);

  145.     pkt->stream_index = 0;

  146.     ret = get_partial_buffer(s->pb, pkt->data, size);

  147.     if (ret <= 0) {

  148.         av_free_packet(pkt);

  149.         return AVERROR(EIO);

  150.     }

  151.     pkt->size = ret;

  152.     return ret;

  153. }

  154. 

  155. // http://www.artificis.hu/files/texts/ingenient.txt

  156. static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)

  157. {

  158.     int ret, size, w, h, unk1, unk2;

  159. 

  160.     if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))

  161.         return AVERROR(EIO); // FIXME

  162. 

  163.     size = get_le32(s->pb);

  164. 

  165.     w = get_le16(s->pb);

  166.     h = get_le16(s->pb);

  167. 

  168.     url_fskip(s->pb, 8); // zero + size (padded?)

  169.     url_fskip(s->pb, 2);

  170.     unk1 = get_le16(s->pb);

  171.     unk2 = get_le16(s->pb);

  172.     url_fskip(s->pb, 22); // ascii timestamp

  173. 

  174.     av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",

  175.         size, w, h, unk1, unk2);

  176. 

  177.     if (av_new_packet(pkt, size) < 0)

  178.         return AVERROR(EIO);

  179. 

  180.     pkt->pos = url_ftell(s->pb);

  181.     pkt->stream_index = 0;

  182.     ret = get_buffer(s->pb, pkt->data, size);

  183.     if (ret <= 0) {

  184.         av_free_packet(pkt);

  185.         return AVERROR(EIO);

  186.     }

  187.     pkt->size = ret;

  188.     return ret;

  189. }

  190. 

  191. static int raw_read_close(AVFormatContext *s)

  192. {

  193.     return 0;

  194. }

  195. 

  196. int pcm_read_seek(AVFormatContext *s,

  197.                   int stream_index, int64_t timestamp, int flags)

  198. {

  199.     AVStream *st;

  200.     int block_align, byte_rate;

  201.     int64_t pos;

  202. 

  203.     st = s->streams[0];

  204. 

  205.     block_align = st->codec->block_align ? st->codec->block_align :

  206.         (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;

  207.     byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :

  208.         block_align * st->codec->sample_rate;

  209. 

  210.     if (block_align <= 0 || byte_rate <= 0)

  211.         return -1;

  212. 

  213.     /* compute the position by aligning it to block_align */

  214.     pos = av_rescale_rnd(timestamp * byte_rate,

  215.                          st->time_base.num,

  216.                          st->time_base.den * (int64_t)block_align,

  217.                          (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);

  218.     pos *= block_align;

  219. 

  220.     /* recompute exact position */

  221.     st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);

  222.     url_fseek(s->pb, pos + s->data_offset, SEEK_SET);

  223.     return 0;

  224. }

  225. 

  226. static int audio_read_header(AVFormatContext *s,

  227.                              AVFormatParameters *ap)

  228. {

  229.     AVStream *st = av_new_stream(s, 0);

  230.     if (!st)

  231.         return AVERROR(ENOMEM);

  232.     st->codec->codec_type = CODEC_TYPE_AUDIO;

  233.     st->codec->codec_id = s->iformat->value;

  234.     st->need_parsing = AVSTREAM_PARSE_FULL;

  235.     /* the parameters will be extracted from the compressed bitstream */

  236.     return 0;

  237. }

  238. 

  239. /* mpeg1/h263 input */

  240. static int video_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. 

  249.     st->codec->codec_type = CODEC_TYPE_VIDEO;

  250.     st->codec->codec_id = s->iformat->value;

  251.     st->need_parsing = AVSTREAM_PARSE_FULL;

  252. 

  253.     /* for mjpeg, specify frame rate */

  254.     /* for mpeg4 specify it too (most mpeg4 streams do not have the fixed_vop_rate set ...)*/

  255.     if (ap->time_base.num) {

  256.         av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);

  257.     } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||

  258.                 st->codec->codec_id == CODEC_ID_MPEG4 ||

  259.                 st->codec->codec_id == CODEC_ID_DIRAC ||

  260.                 st->codec->codec_id == CODEC_ID_H264) {

  261.         av_set_pts_info(st, 64, 1, 25);

  262.     }

  263. 

  264.     return 0;

  265. }

  266. 

  267. #define SEQ_START_CODE          0x000001b3

  268. #define GOP_START_CODE          0x000001b8

  269. #define PICTURE_START_CODE      0x00000100

  270. #define SLICE_START_CODE        0x00000101

  271. #define PACK_START_CODE         0x000001ba

  272. #define VIDEO_ID                0x000001e0

  273. #define AUDIO_ID                0x000001c0

  274. 

  275. static int mpegvideo_probe(AVProbeData *p)

  276. {

  277.     uint32_t code= -1;

  278.     int pic=0, seq=0, slice=0, pspack=0, pes=0;

  279.     int i;

  280. 

  281.     for(i=0; i<p->buf_size; i++){

  282.         code = (code<<8) + p->buf[i];

  283.         if ((code & 0xffffff00) == 0x100) {

  284.             switch(code){

  285.             case     SEQ_START_CODE:   seq++; break;

  286.             case PICTURE_START_CODE:   pic++; break;

  287.             case   SLICE_START_CODE: slice++; break;

  288.             case    PACK_START_CODE: pspack++; break;

  289.             }

  290.             if     ((code & 0x1f0) == VIDEO_ID)   pes++;

  291.             else if((code & 0x1e0) == AUDIO_ID)   pes++;

  292.         }

  293.     }

  294.     if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)

  295.         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg

  296.     return 0;

  297. }

  298. 

  299. #define VISUAL_OBJECT_START_CODE       0x000001b5

  300. #define VOP_START_CODE                 0x000001b6

  301. 

  302. static int mpeg4video_probe(AVProbeData *probe_packet)

  303. {

  304.     uint32_t temp_buffer= -1;

  305.     int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;

  306.     int i;

  307. 

  308.     for(i=0; i<probe_packet->buf_size; i++){

  309.         temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];

  310.         if ((temp_buffer & 0xffffff00) != 0x100)

  311.             continue;

  312. 

  313.         if (temp_buffer == VOP_START_CODE)                         VOP++;

  314.         else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;

  315.         else if (temp_buffer < 0x120)                              VO++;

  316.         else if (temp_buffer < 0x130)                              VOL++;

  317.         else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)

  318.                  && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;

  319.     }

  320. 

  321.     if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)

  322.         return AVPROBE_SCORE_MAX/2;

  323.     return 0;

  324. }

  325. 

  326. static int h263_probe(AVProbeData *p)

  327. {

  328.     int code;

  329.     const uint8_t *d;

  330. 

  331.     d = p->buf;

  332.     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);

  333.     if (code == 0x20) {

  334.         return 50;

  335.     }

  336.     return 0;

  337. }

  338. 

  339. static int h261_probe(AVProbeData *p)

  340. {

  341.     int code;

  342.     const uint8_t *d;

  343. 

  344.     d = p->buf;

  345.     code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);

  346.     if (code == 0x10) {

  347.         return 50;

  348.     }

  349.     return 0;

  350. }

  351. 

  352. #define DCA_MARKER_14B_BE 0x1FFFE800

  353. #define DCA_MARKER_14B_LE 0xFF1F00E8

  354. #define DCA_MARKER_RAW_BE 0x7FFE8001

  355. #define DCA_MARKER_RAW_LE 0xFE7F0180

  356. static int dts_probe(AVProbeData *p)

  357. {

  358.     const uint8_t *buf, *bufp;

  359.     uint32_t state = -1;

  360. 

  361.     buf = p->buf;

  362. 

  363.     for(; buf < (p->buf+p->buf_size)-2; buf+=2) {

  364.         bufp = buf;

  365.         state = (state << 16) | bytestream_get_be16(&bufp);

  366. 

  367.         /* Regular bitstream */

  368.         if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)

  369.             return AVPROBE_SCORE_MAX/2+1;

  370. 

  371.         /* 14 bits big endian bitstream */

  372.         if (state == DCA_MARKER_14B_BE)

  373.             if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)

  374.                 return AVPROBE_SCORE_MAX/2+1;

  375. 

  376.         /* 14 bits little endian bitstream */

  377.         if (state == DCA_MARKER_14B_LE)

  378.             if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)

  379.                 return AVPROBE_SCORE_MAX/2+1;

  380.     }

  381. 

  382.     return 0;

  383. }

  384. 

  385. static int dirac_probe(AVProbeData *p)

  386. {

  387.     if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))

  388.         return AVPROBE_SCORE_MAX;

  389.     else

  390.         return 0;

  391. }

  392. 

  393. static int ac3_probe(AVProbeData *p)

  394. {

  395.     int max_frames, first_frames = 0, frames;

  396.     uint8_t *buf, *buf2, *end;

  397.     AC3HeaderInfo hdr;

  398.     GetBitContext gbc;

  399. 

  400.     max_frames = 0;

  401.     buf = p->buf;

  402.     end = buf + p->buf_size;

  403. 

  404.     for(; buf < end; buf++) {

  405.         buf2 = buf;

  406. 

  407.         for(frames = 0; buf2 < end; frames++) {

  408.             init_get_bits(&gbc, buf2, 54);

  409.             if(ff_ac3_parse_header(&gbc, &hdr) < 0)

  410.                 break;

  411.             if(buf2 + hdr.frame_size > end ||

  412.                av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))

  413.                 break;

  414.             buf2 += hdr.frame_size;

  415.         }

  416.         max_frames = FFMAX(max_frames, frames);

  417.         if(buf == p->buf)

  418.             first_frames = frames;

  419.     }

  420.     if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;

  421.     else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;

  422.     else if(max_frames>=1) return 1;

  423.     else                   return 0;

  424. }

  425. 

  426. static int flac_probe(AVProbeData *p)

  427. {

  428.     if(memcmp(p->buf, "fLaC", 4)) return 0;

  429.     else                          return AVPROBE_SCORE_MAX / 2;

  430. }

  431. 

  432. AVInputFormat shorten_demuxer = {

  433.     "shn",

  434.     NULL_IF_CONFIG_SMALL("raw Shorten"),

  435.     0,

  436.     NULL,

  437.     audio_read_header,

  438.     raw_read_partial_packet,

  439.     raw_read_close,

  440.     .flags= AVFMT_GENERIC_INDEX,

  441.     .extensions = "shn",

  442.     .value = CODEC_ID_SHORTEN,

  443. };

  444. 

  445. AVInputFormat mlp_demuxer = {

  446.     "mlp",

  447.     NULL_IF_CONFIG_SMALL("raw MLP"),

  448.     0,

  449.     NULL,

  450.     audio_read_header,

  451.     raw_read_partial_packet,

  452.     raw_read_close,

  453.     .flags= AVFMT_GENERIC_INDEX,

  454.     .extensions = "mlp",

  455.     .value = CODEC_ID_MLP,

  456. };

  457. 

  458. AVInputFormat flac_demuxer = {

  459.     "flac",

  460.     NULL_IF_CONFIG_SMALL("raw FLAC"),

  461.     0,

  462.     flac_probe,

  463.     audio_read_header,

  464.     raw_read_partial_packet,

  465.     raw_read_close,

  466.     .flags= AVFMT_GENERIC_INDEX,

  467.     .extensions = "flac",

  468.     .value = CODEC_ID_FLAC,

  469. };

  470. 

  471. #ifdef CONFIG_MUXERS

  472. AVOutputFormat flac_muxer = {

  473.     "flac",

  474.     NULL_IF_CONFIG_SMALL("raw FLAC"),

  475.     "audio/x-flac",

  476.     "flac",

  477.     0,

  478.     CODEC_ID_FLAC,

  479.     CODEC_ID_NONE,

  480.     flac_write_header,

  481.     raw_write_packet,

  482.     .flags= AVFMT_NOTIMESTAMPS,

  483. };

  484. #endif //CONFIG_MUXERS

  485. 

  486. #ifdef CONFIG_AC3_DEMUXER

  487. AVInputFormat ac3_demuxer = {

  488.     "ac3",

  489.     NULL_IF_CONFIG_SMALL("raw AC-3"),

  490.     0,

  491.     ac3_probe,

  492.     audio_read_header,

  493.     raw_read_partial_packet,

  494.     raw_read_close,

  495.     .flags= AVFMT_GENERIC_INDEX,

  496.     .extensions = "ac3",

  497.     .value = CODEC_ID_AC3,

  498. };

  499. #endif

  500. 

  501. #ifdef CONFIG_MUXERS

  502. AVOutputFormat ac3_muxer = {

  503.     "ac3",

  504.     NULL_IF_CONFIG_SMALL("raw AC-3"),

  505.     "audio/x-ac3",

  506.     "ac3",

  507.     0,

  508.     CODEC_ID_AC3,

  509.     CODEC_ID_NONE,

  510.     NULL,

  511.     raw_write_packet,

  512.     .flags= AVFMT_NOTIMESTAMPS,

  513. };

  514. 

  515. AVOutputFormat dts_muxer = {

  516.     "dts",

  517.     NULL_IF_CONFIG_SMALL("raw DTS"),

  518.     "audio/x-dca",

  519.     "dts",

  520.     0,

  521.     CODEC_ID_DTS,

  522.     CODEC_ID_NONE,

  523.     NULL,

  524.     raw_write_packet,

  525.     .flags= AVFMT_NOTIMESTAMPS,

  526. };

  527. 

  528. #endif //CONFIG_MUXERS

  529. 

  530. AVInputFormat dirac_demuxer = {

  531.     "dirac",

  532.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  533.     0,

  534.     dirac_probe,

  535.     video_read_header,

  536.     raw_read_partial_packet,

  537.     raw_read_close,

  538.     .flags= AVFMT_GENERIC_INDEX,

  539.     .value = CODEC_ID_DIRAC,

  540. };

  541. 

  542. #ifdef CONFIG_MUXERS

  543. AVOutputFormat dirac_muxer = {

  544.     "dirac",

  545.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  546.     NULL,

  547.     "drc",

  548.     0,

  549.     CODEC_ID_NONE,

  550.     CODEC_ID_DIRAC,

  551.     NULL,

  552.     raw_write_packet,

  553.     .flags= AVFMT_NOTIMESTAMPS,

  554. };

  555. #endif

  556. 

  557. AVInputFormat dts_demuxer = {

  558.     "dts",

  559.     NULL_IF_CONFIG_SMALL("raw DTS"),

  560.     0,

  561.     dts_probe,

  562.     audio_read_header,

  563.     raw_read_partial_packet,

  564.     raw_read_close,

  565.     .flags= AVFMT_GENERIC_INDEX,

  566.     .extensions = "dts",

  567.     .value = CODEC_ID_DTS,

  568. };

  569. 

  570. AVInputFormat aac_demuxer = {

  571.     "aac",

  572.     NULL_IF_CONFIG_SMALL("ADTS AAC"),

  573.     0,

  574.     NULL,

  575.     audio_read_header,

  576.     raw_read_partial_packet,

  577.     raw_read_close,

  578.     .flags= AVFMT_GENERIC_INDEX,

  579.     .extensions = "aac",

  580.     .value = CODEC_ID_AAC,

  581. };

  582. 

  583. AVInputFormat gsm_demuxer = {

  584.     "gsm",

  585.     NULL_IF_CONFIG_SMALL("GSM"),

  586.     0,

  587.     NULL,

  588.     audio_read_header,

  589.     raw_read_partial_packet,

  590.     raw_read_close,

  591.     .flags= AVFMT_GENERIC_INDEX,

  592.     .extensions = "gsm",

  593.     .value = CODEC_ID_GSM,

  594. };

  595. 

  596. #ifdef CONFIG_ROQ_MUXER

  597. AVOutputFormat roq_muxer =

  598. {

  599.     "RoQ",

  600.     NULL_IF_CONFIG_SMALL("id RoQ format"),

  601.     NULL,

  602.     "roq",

  603.     0,

  604.     CODEC_ID_ROQ_DPCM,

  605.     CODEC_ID_ROQ,

  606.     roq_write_header,

  607.     raw_write_packet,

  608. };

  609. #endif //CONFIG_ROQ_MUXER

  610. 

  611. AVInputFormat h261_demuxer = {

  612.     "h261",

  613.     NULL_IF_CONFIG_SMALL("raw H.261"),

  614.     0,

  615.     h261_probe,

  616.     video_read_header,

  617.     raw_read_partial_packet,

  618.     raw_read_close,

  619.     .flags= AVFMT_GENERIC_INDEX,

  620.     .extensions = "h261",

  621.     .value = CODEC_ID_H261,

  622. };

  623. 

  624. #ifdef CONFIG_MUXERS

  625. AVOutputFormat h261_muxer = {

  626.     "h261",

  627.     NULL_IF_CONFIG_SMALL("raw H.261"),

  628.     "video/x-h261",

  629.     "h261",

  630.     0,

  631.     CODEC_ID_NONE,

  632.     CODEC_ID_H261,

  633.     NULL,

  634.     raw_write_packet,

  635.     .flags= AVFMT_NOTIMESTAMPS,

  636. };

  637. #endif //CONFIG_MUXERS

  638. 

  639. AVInputFormat h263_demuxer = {

  640.     "h263",

  641.     NULL_IF_CONFIG_SMALL("raw H.263"),

  642.     0,

  643.     h263_probe,

  644.     video_read_header,

  645.     raw_read_partial_packet,

  646.     raw_read_close,

  647.     .flags= AVFMT_GENERIC_INDEX,

  648. //    .extensions = "h263", //FIXME remove after writing mpeg4_probe

  649.     .value = CODEC_ID_H263,

  650. };

  651. 

  652. #ifdef CONFIG_MUXERS

  653. AVOutputFormat h263_muxer = {

  654.     "h263",

  655.     NULL_IF_CONFIG_SMALL("raw H.263"),

  656.     "video/x-h263",

  657.     "h263",

  658.     0,

  659.     CODEC_ID_NONE,

  660.     CODEC_ID_H263,

  661.     NULL,

  662.     raw_write_packet,

  663.     .flags= AVFMT_NOTIMESTAMPS,

  664. };

  665. #endif //CONFIG_MUXERS

  666. 

  667. AVInputFormat m4v_demuxer = {

  668.     "m4v",

  669.     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),

  670.     0,

  671.     mpeg4video_probe, /** probing for mpeg4 data */

  672.     video_read_header,

  673.     raw_read_partial_packet,

  674.     raw_read_close,

  675.     .flags= AVFMT_GENERIC_INDEX,

  676.     .extensions = "m4v", //FIXME remove after writing mpeg4_probe

  677.     .value = CODEC_ID_MPEG4,

  678. };

  679. 

  680. #ifdef CONFIG_MUXERS

  681. AVOutputFormat m4v_muxer = {

  682.     "m4v",

  683.     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),

  684.     NULL,

  685.     "m4v",

  686.     0,

  687.     CODEC_ID_NONE,

  688.     CODEC_ID_MPEG4,

  689.     NULL,

  690.     raw_write_packet,

  691.     .flags= AVFMT_NOTIMESTAMPS,

  692. };

  693. #endif //CONFIG_MUXERS

  694. 

  695. AVInputFormat h264_demuxer = {

  696.     "h264",

  697.     NULL_IF_CONFIG_SMALL("raw H.264 video format"),

  698.     0,

  699.     NULL /*mpegvideo_probe*/,

  700.     video_read_header,

  701.     raw_read_partial_packet,

  702.     raw_read_close,

  703.     .flags= AVFMT_GENERIC_INDEX,

  704.     .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe

  705.     .value = CODEC_ID_H264,

  706. };

  707. 

  708. #ifdef CONFIG_MUXERS

  709. AVOutputFormat h264_muxer = {

  710.     "h264",

  711.     NULL_IF_CONFIG_SMALL("raw H.264 video format"),

  712.     NULL,

  713.     "h264",

  714.     0,

  715.     CODEC_ID_NONE,

  716.     CODEC_ID_H264,

  717.     NULL,

  718.     raw_write_packet,

  719.     .flags= AVFMT_NOTIMESTAMPS,

  720. };

  721. #endif //CONFIG_MUXERS

  722. 

  723. AVInputFormat mpegvideo_demuxer = {

  724.     "mpegvideo",

  725.     NULL_IF_CONFIG_SMALL("MPEG video"),

  726.     0,

  727.     mpegvideo_probe,

  728.     video_read_header,

  729.     raw_read_partial_packet,

  730.     raw_read_close,

  731.     .flags= AVFMT_GENERIC_INDEX,

  732.     .value = CODEC_ID_MPEG1VIDEO,

  733. };

  734. 

  735. #ifdef CONFIG_MUXERS

  736. AVOutputFormat mpeg1video_muxer = {

  737.     "mpeg1video",

  738.     NULL_IF_CONFIG_SMALL("MPEG video"),

  739.     "video/x-mpeg",

  740.     "mpg,mpeg,m1v",

  741.     0,

  742.     CODEC_ID_NONE,

  743.     CODEC_ID_MPEG1VIDEO,

  744.     NULL,

  745.     raw_write_packet,

  746.     .flags= AVFMT_NOTIMESTAMPS,

  747. };

  748. #endif //CONFIG_MUXERS

  749. 

  750. #ifdef CONFIG_MUXERS

  751. AVOutputFormat mpeg2video_muxer = {

  752.     "mpeg2video",

  753.     NULL_IF_CONFIG_SMALL("MPEG-2 video"),

  754.     NULL,

  755.     "m2v",

  756.     0,

  757.     CODEC_ID_NONE,

  758.     CODEC_ID_MPEG2VIDEO,

  759.     NULL,

  760.     raw_write_packet,

  761.     .flags= AVFMT_NOTIMESTAMPS,

  762. };

  763. #endif //CONFIG_MUXERS

  764. 

  765. AVInputFormat mjpeg_demuxer = {

  766.     "mjpeg",

  767.     NULL_IF_CONFIG_SMALL("MJPEG video"),

  768.     0,

  769.     NULL,

  770.     video_read_header,

  771.     raw_read_partial_packet,

  772.     raw_read_close,

  773.     .flags= AVFMT_GENERIC_INDEX,

  774.     .extensions = "mjpg,mjpeg",

  775.     .value = CODEC_ID_MJPEG,

  776. };

  777. 

  778. AVInputFormat ingenient_demuxer = {

  779.     "ingenient",

  780.     NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),

  781.     0,

  782.     NULL,

  783.     video_read_header,

  784.     ingenient_read_packet,

  785.     raw_read_close,

  786.     .flags= AVFMT_GENERIC_INDEX,

  787.     .extensions = "cgi", // FIXME

  788.     .value = CODEC_ID_MJPEG,

  789. };

  790. 

  791. #ifdef CONFIG_MUXERS

  792. AVOutputFormat mjpeg_muxer = {

  793.     "mjpeg",

  794.     NULL_IF_CONFIG_SMALL("MJPEG video"),

  795.     "video/x-mjpeg",

  796.     "mjpg,mjpeg",

  797.     0,

  798.     CODEC_ID_NONE,

  799.     CODEC_ID_MJPEG,

  800.     NULL,

  801.     raw_write_packet,

  802.     .flags= AVFMT_NOTIMESTAMPS,

  803. };

  804. #endif //CONFIG_MUXERS

  805. 

  806. AVInputFormat vc1_demuxer = {

  807.     "vc1",

  808.     NULL_IF_CONFIG_SMALL("raw VC-1"),

  809.     0,

  810.     NULL /* vc1_probe */,

  811.     video_read_header,

  812.     raw_read_partial_packet,

  813.     raw_read_close,

  814.     .extensions = "vc1",

  815.     .value = CODEC_ID_VC1,

  816. };

  817. 

  818. /* pcm formats */

  819. 

  820. #define PCMINPUTDEF(name, long_name, ext, codec) \

  821. AVInputFormat pcm_ ## name ## _demuxer = {\

  822.     #name,\

  823.     NULL_IF_CONFIG_SMALL(long_name),\

  824.     0,\

  825.     NULL,\

  826.     raw_read_header,\

  827.     raw_read_packet,\

  828.     raw_read_close,\

  829.     pcm_read_seek,\

  830.     .flags= AVFMT_GENERIC_INDEX,\

  831.     .extensions = ext,\

  832.     .value = codec,\

  833. };

  834. 

  835. #define PCMOUTPUTDEF(name, long_name, ext, codec) \

  836. AVOutputFormat pcm_ ## name ## _muxer = {\

  837.     #name,\

  838.     NULL_IF_CONFIG_SMALL(long_name),\

  839.     NULL,\

  840.     ext,\

  841.     0,\

  842.     codec,\

  843.     CODEC_ID_NONE,\

  844.     NULL,\

  845.     raw_write_packet,\

  846.     .flags= AVFMT_NOTIMESTAMPS,\

  847. };

  848. 

  849. 

  850. #if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)

  851. #define PCMDEF(name, long_name, ext, codec) \

  852.         PCMINPUTDEF(name, long_name, ext, codec)

  853. #elif defined(CONFIG_MUXERS) && !defined(CONFIG_DEMUXERS)

  854. #define PCMDEF(name, long_name, ext, codec) \

  855.         PCMOUTPUTDEF(name, long_name, ext, codec)

  856. #elif defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)

  857. #define PCMDEF(name, long_name, ext, codec) \

  858.         PCMINPUTDEF(name, long_name, ext, codec)\

  859.         PCMOUTPUTDEF(name, long_name, ext, codec)

  860. #else

  861. #define PCMDEF(name, long_name, ext, codec)

  862. #endif

  863. 

  864. #ifdef WORDS_BIGENDIAN

  865. #define BE_DEF(s) s

  866. #define LE_DEF(s) NULL

  867. #else

  868. #define BE_DEF(s) NULL

  869. #define LE_DEF(s) s

  870. #endif

  871. 

  872. 

  873. PCMDEF(s16le, "pcm signed 16 bit little endian format",

  874.        LE_DEF("sw"), CODEC_ID_PCM_S16LE)

  875. 

  876. PCMDEF(s16be, "pcm signed 16 bit big endian format",

  877.        BE_DEF("sw"), CODEC_ID_PCM_S16BE)

  878. 

  879. PCMDEF(u16le, "pcm unsigned 16 bit little endian format",

  880.        LE_DEF("uw"), CODEC_ID_PCM_U16LE)

  881. 

  882. PCMDEF(u16be, "pcm unsigned 16 bit big endian format",

  883.        BE_DEF("uw"), CODEC_ID_PCM_U16BE)

  884. 

  885. PCMDEF(s8, "pcm signed 8 bit format",

  886.        "sb", CODEC_ID_PCM_S8)

  887. 

  888. PCMDEF(u8, "pcm unsigned 8 bit format",

  889.        "ub", CODEC_ID_PCM_U8)

  890. 

  891. PCMDEF(mulaw, "pcm mu law format",

  892.        "ul", CODEC_ID_PCM_MULAW)

  893. 

  894. PCMDEF(alaw, "pcm A law format",

  895.        "al", CODEC_ID_PCM_ALAW)

  896. 

  897. static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)

  898. {

  899.     int packet_size, ret, width, height;

  900.     AVStream *st = s->streams[0];

  901. 

  902.     width = st->codec->width;

  903.     height = st->codec->height;

  904. 

  905.     packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);

  906.     if (packet_size < 0)

  907.         return -1;

  908. 

  909.     ret= av_get_packet(s->pb, pkt, packet_size);

  910.     pkt->pts=

  911.     pkt->dts= pkt->pos / packet_size;

  912. 

  913.     pkt->stream_index = 0;

  914.     if (ret != packet_size) {

  915.         return AVERROR(EIO);

  916.     } else {

  917.         return 0;

  918.     }

  919. }

  920. 

  921. AVInputFormat rawvideo_demuxer = {

  922.     "rawvideo",

  923.     NULL_IF_CONFIG_SMALL("raw video format"),

  924.     0,

  925.     NULL,

  926.     raw_read_header,

  927.     rawvideo_read_packet,

  928.     raw_read_close,

  929.     .flags= AVFMT_GENERIC_INDEX,

  930.     .extensions = "yuv,cif,qcif,rgb",

  931.     .value = CODEC_ID_RAWVIDEO,

  932. };

  933. 

  934. #ifdef CONFIG_MUXERS

  935. AVOutputFormat rawvideo_muxer = {

  936.     "rawvideo",

  937.     NULL_IF_CONFIG_SMALL("raw video format"),

  938.     NULL,

  939.     "yuv,rgb",

  940.     0,

  941.     CODEC_ID_NONE,

  942.     CODEC_ID_RAWVIDEO,

  943.     NULL,

  944.     raw_write_packet,

  945.     .flags= AVFMT_NOTIMESTAMPS,

  946. };

  947. #endif //CONFIG_MUXERS

  948. 

  949. #ifdef CONFIG_MUXERS

  950. static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)

  951. {

  952.     return 0;

  953. }

  954. 

  955. AVOutputFormat null_muxer = {

  956.     "null",

  957.     NULL_IF_CONFIG_SMALL("null video format"),

  958.     NULL,

  959.     NULL,

  960.     0,

  961. #ifdef WORDS_BIGENDIAN

  962.     CODEC_ID_PCM_S16BE,

  963. #else

  964.     CODEC_ID_PCM_S16LE,

  965. #endif

  966.     CODEC_ID_RAWVIDEO,

  967.     NULL,

  968.     null_write_packet,

  969.     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,

  970. };

  971. #endif //CONFIG_MUXERS