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.
25825 Commits
32 Branches
1.0GB
Tree: f1714d5846
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f1714d5846'
${ noResults }
FFmpeg/libavformat/raw.c

527 lines
12KB
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 "avformat.h"

  24. #include "raw.h"

  25. 

  26. /* simple formats */

  27. 

  28. #if CONFIG_MUXERS

  29. int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)

  30. {

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

  32.     put_flush_packet(s->pb);

  33.     return 0;

  34. }

  35. #endif

  36. 

  37. #if CONFIG_DEMUXERS

  38. /* raw input */

  39. int ff_raw_read_header(AVFormatContext *s, AVFormatParameters *ap)

  40. {

  41.     AVStream *st;

  42.     enum CodecID id;

  43. 

  44.     st = av_new_stream(s, 0);

  45.     if (!st)

  46.         return AVERROR(ENOMEM);

  47. 

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

  49.         if (id == CODEC_ID_RAWVIDEO) {

  50.             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

  51.         } else {

  52.             st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

  53.         }

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

  55. 

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

  57.         case AVMEDIA_TYPE_AUDIO:

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

  59.             if(ap->channels) st->codec->channels = ap->channels;

  60.             else             st->codec->channels = 1;

  61.             st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id);

  62.             assert(st->codec->bits_per_coded_sample > 0);

  63.             st->codec->block_align = st->codec->bits_per_coded_sample*st->codec->channels/8;

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

  65.             break;

  66.         case AVMEDIA_TYPE_VIDEO:

  67.             if(ap->time_base.num)

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

  69.             else

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

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

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

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

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

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

  76.             break;

  77.         default:

  78.             return -1;

  79.         }

  80.     return 0;

  81. }

  82. 

  83. #define RAW_PACKET_SIZE 1024

  84. 

  85. int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)

  86. {

  87.     int ret, size;

  88. 

  89.     size = RAW_PACKET_SIZE;

  90. 

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

  92.         return AVERROR(ENOMEM);

  93. 

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

  95.     pkt->stream_index = 0;

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

  97.     if (ret < 0) {

  98.         av_free_packet(pkt);

  99.         return ret;

  100.     }

  101.     pkt->size = ret;

  102.     return ret;

  103. }

  104. #endif

  105. 

  106. #if CONFIG_RAWVIDEO_DEMUXER

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

  108. {

  109.     int packet_size, ret, width, height;

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

  111. 

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

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

  114. 

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

  116.     if (packet_size < 0)

  117.         return -1;

  118. 

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

  120.     pkt->pts=

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

  122. 

  123.     pkt->stream_index = 0;

  124.     if (ret < 0)

  125.         return ret;

  126.     return 0;

  127. }

  128. #endif

  129. 

  130. #if CONFIG_DEMUXERS

  131. int ff_raw_audio_read_header(AVFormatContext *s,

  132.                              AVFormatParameters *ap)

  133. {

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

  135.     if (!st)

  136.         return AVERROR(ENOMEM);

  137.     st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

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

  139.     st->need_parsing = AVSTREAM_PARSE_FULL;

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

  141. 

  142.     return 0;

  143. }

  144. 

  145. /* MPEG-1/H.263 input */

  146. int ff_raw_video_read_header(AVFormatContext *s,

  147.                              AVFormatParameters *ap)

  148. {

  149.     AVStream *st;

  150. 

  151.     st = av_new_stream(s, 0);

  152.     if (!st)

  153.         return AVERROR(ENOMEM);

  154. 

  155.     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

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

  157.     st->need_parsing = AVSTREAM_PARSE_FULL;

  158. 

  159.     /* for MJPEG, specify frame rate */

  160.     /* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop_rate set ...)*/

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

  162.         st->codec->time_base= ap->time_base;

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

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

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

  166.                 st->codec->codec_id == CODEC_ID_DNXHD ||

  167.                 st->codec->codec_id == CODEC_ID_VC1   ||

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

  169.         st->codec->time_base= (AVRational){1,25};

  170.     }

  171.     av_set_pts_info(st, 64, 1, 1200000);

  172. 

  173.     return 0;

  174. }

  175. #endif

  176. 

  177. /* Note: Do not forget to add new entries to the Makefile as well. */

  178. 

  179. #if CONFIG_AC3_MUXER

  180. AVOutputFormat ac3_muxer = {

  181.     "ac3",

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

  183.     "audio/x-ac3",

  184.     "ac3",

  185.     0,

  186.     CODEC_ID_AC3,

  187.     CODEC_ID_NONE,

  188.     NULL,

  189.     ff_raw_write_packet,

  190.     .flags= AVFMT_NOTIMESTAMPS,

  191. };

  192. #endif

  193. 

  194. #if CONFIG_DIRAC_MUXER

  195. AVOutputFormat dirac_muxer = {

  196.     "dirac",

  197.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  198.     NULL,

  199.     "drc",

  200.     0,

  201.     CODEC_ID_NONE,

  202.     CODEC_ID_DIRAC,

  203.     NULL,

  204.     ff_raw_write_packet,

  205.     .flags= AVFMT_NOTIMESTAMPS,

  206. };

  207. #endif

  208. 

  209. #if CONFIG_DNXHD_MUXER

  210. AVOutputFormat dnxhd_muxer = {

  211.     "dnxhd",

  212.     NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),

  213.     NULL,

  214.     "dnxhd",

  215.     0,

  216.     CODEC_ID_NONE,

  217.     CODEC_ID_DNXHD,

  218.     NULL,

  219.     ff_raw_write_packet,

  220.     .flags= AVFMT_NOTIMESTAMPS,

  221. };

  222. #endif

  223. 

  224. #if CONFIG_DTS_MUXER

  225. AVOutputFormat dts_muxer = {

  226.     "dts",

  227.     NULL_IF_CONFIG_SMALL("raw DTS"),

  228.     "audio/x-dca",

  229.     "dts",

  230.     0,

  231.     CODEC_ID_DTS,

  232.     CODEC_ID_NONE,

  233.     NULL,

  234.     ff_raw_write_packet,

  235.     .flags= AVFMT_NOTIMESTAMPS,

  236. };

  237. #endif

  238. 

  239. #if CONFIG_EAC3_MUXER

  240. AVOutputFormat eac3_muxer = {

  241.     "eac3",

  242.     NULL_IF_CONFIG_SMALL("raw E-AC-3"),

  243.     "audio/x-eac3",

  244.     "eac3",

  245.     0,

  246.     CODEC_ID_EAC3,

  247.     CODEC_ID_NONE,

  248.     NULL,

  249.     ff_raw_write_packet,

  250.     .flags= AVFMT_NOTIMESTAMPS,

  251. };

  252. #endif

  253. 

  254. #if CONFIG_GSM_DEMUXER

  255. AVInputFormat gsm_demuxer = {

  256.     "gsm",

  257.     NULL_IF_CONFIG_SMALL("raw GSM"),

  258.     0,

  259.     NULL,

  260.     ff_raw_audio_read_header,

  261.     ff_raw_read_partial_packet,

  262.     .flags= AVFMT_GENERIC_INDEX,

  263.     .extensions = "gsm",

  264.     .value = CODEC_ID_GSM,

  265. };

  266. #endif

  267. 

  268. #if CONFIG_H261_MUXER

  269. AVOutputFormat h261_muxer = {

  270.     "h261",

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

  272.     "video/x-h261",

  273.     "h261",

  274.     0,

  275.     CODEC_ID_NONE,

  276.     CODEC_ID_H261,

  277.     NULL,

  278.     ff_raw_write_packet,

  279.     .flags= AVFMT_NOTIMESTAMPS,

  280. };

  281. #endif

  282. 

  283. #if CONFIG_H263_MUXER

  284. AVOutputFormat h263_muxer = {

  285.     "h263",

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

  287.     "video/x-h263",

  288.     "h263",

  289.     0,

  290.     CODEC_ID_NONE,

  291.     CODEC_ID_H263,

  292.     NULL,

  293.     ff_raw_write_packet,

  294.     .flags= AVFMT_NOTIMESTAMPS,

  295. };

  296. #endif

  297. 

  298. #if CONFIG_H264_MUXER

  299. AVOutputFormat h264_muxer = {

  300.     "h264",

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

  302.     NULL,

  303.     "h264",

  304.     0,

  305.     CODEC_ID_NONE,

  306.     CODEC_ID_H264,

  307.     NULL,

  308.     ff_raw_write_packet,

  309.     .flags= AVFMT_NOTIMESTAMPS,

  310. };

  311. #endif

  312. 

  313. #if CONFIG_CAVSVIDEO_MUXER

  314. AVOutputFormat cavsvideo_muxer = {

  315.     "cavsvideo",

  316.     NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),

  317.     NULL,

  318.     "cavs",

  319.     0,

  320.     CODEC_ID_NONE,

  321.     CODEC_ID_CAVS,

  322.     NULL,

  323.     ff_raw_write_packet,

  324.     .flags= AVFMT_NOTIMESTAMPS,

  325. };

  326. #endif

  327. 

  328. #if CONFIG_M4V_MUXER

  329. AVOutputFormat m4v_muxer = {

  330.     "m4v",

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

  332.     NULL,

  333.     "m4v",

  334.     0,

  335.     CODEC_ID_NONE,

  336.     CODEC_ID_MPEG4,

  337.     NULL,

  338.     ff_raw_write_packet,

  339.     .flags= AVFMT_NOTIMESTAMPS,

  340. };

  341. #endif

  342. 

  343. #if CONFIG_MJPEG_DEMUXER

  344. AVInputFormat mjpeg_demuxer = {

  345.     "mjpeg",

  346.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  347.     0,

  348.     NULL,

  349.     ff_raw_video_read_header,

  350.     ff_raw_read_partial_packet,

  351.     .flags= AVFMT_GENERIC_INDEX,

  352.     .extensions = "mjpg,mjpeg",

  353.     .value = CODEC_ID_MJPEG,

  354. };

  355. #endif

  356. 

  357. #if CONFIG_MJPEG_MUXER

  358. AVOutputFormat mjpeg_muxer = {

  359.     "mjpeg",

  360.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  361.     "video/x-mjpeg",

  362.     "mjpg,mjpeg",

  363.     0,

  364.     CODEC_ID_NONE,

  365.     CODEC_ID_MJPEG,

  366.     NULL,

  367.     ff_raw_write_packet,

  368.     .flags= AVFMT_NOTIMESTAMPS,

  369. };

  370. #endif

  371. 

  372. #if CONFIG_MLP_DEMUXER

  373. AVInputFormat mlp_demuxer = {

  374.     "mlp",

  375.     NULL_IF_CONFIG_SMALL("raw MLP"),

  376.     0,

  377.     NULL,

  378.     ff_raw_audio_read_header,

  379.     ff_raw_read_partial_packet,

  380.     .flags= AVFMT_GENERIC_INDEX,

  381.     .extensions = "mlp",

  382.     .value = CODEC_ID_MLP,

  383. };

  384. #endif

  385. 

  386. #if CONFIG_MLP_MUXER

  387. AVOutputFormat mlp_muxer = {

  388.     "mlp",

  389.     NULL_IF_CONFIG_SMALL("raw MLP"),

  390.     NULL,

  391.     "mlp",

  392.     0,

  393.     CODEC_ID_MLP,

  394.     CODEC_ID_NONE,

  395.     NULL,

  396.     ff_raw_write_packet,

  397.     .flags= AVFMT_NOTIMESTAMPS,

  398. };

  399. #endif

  400. 

  401. #if CONFIG_SRT_MUXER

  402. AVOutputFormat srt_muxer = {

  403.     .name           = "srt",

  404.     .long_name      = NULL_IF_CONFIG_SMALL("SubRip subtitle format"),

  405.     .mime_type      = "application/x-subrip",

  406.     .extensions     = "srt",

  407.     .write_packet   = ff_raw_write_packet,

  408.     .flags          = AVFMT_NOTIMESTAMPS,

  409.     .subtitle_codec = CODEC_ID_SRT,

  410. };

  411. #endif

  412. 

  413. #if CONFIG_TRUEHD_DEMUXER

  414. AVInputFormat truehd_demuxer = {

  415.     "truehd",

  416.     NULL_IF_CONFIG_SMALL("raw TrueHD"),

  417.     0,

  418.     NULL,

  419.     ff_raw_audio_read_header,

  420.     ff_raw_read_partial_packet,

  421.     .flags= AVFMT_GENERIC_INDEX,

  422.     .extensions = "thd",

  423.     .value = CODEC_ID_TRUEHD,

  424. };

  425. #endif

  426. 

  427. #if CONFIG_TRUEHD_MUXER

  428. AVOutputFormat truehd_muxer = {

  429.     "truehd",

  430.     NULL_IF_CONFIG_SMALL("raw TrueHD"),

  431.     NULL,

  432.     "thd",

  433.     0,

  434.     CODEC_ID_TRUEHD,

  435.     CODEC_ID_NONE,

  436.     NULL,

  437.     ff_raw_write_packet,

  438.     .flags= AVFMT_NOTIMESTAMPS,

  439. };

  440. #endif

  441. 

  442. #if CONFIG_MPEG1VIDEO_MUXER

  443. AVOutputFormat mpeg1video_muxer = {

  444.     "mpeg1video",

  445.     NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),

  446.     "video/x-mpeg",

  447.     "mpg,mpeg,m1v",

  448.     0,

  449.     CODEC_ID_NONE,

  450.     CODEC_ID_MPEG1VIDEO,

  451.     NULL,

  452.     ff_raw_write_packet,

  453.     .flags= AVFMT_NOTIMESTAMPS,

  454. };

  455. #endif

  456. 

  457. #if CONFIG_MPEG2VIDEO_MUXER

  458. AVOutputFormat mpeg2video_muxer = {

  459.     "mpeg2video",

  460.     NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),

  461.     NULL,

  462.     "m2v",

  463.     0,

  464.     CODEC_ID_NONE,

  465.     CODEC_ID_MPEG2VIDEO,

  466.     NULL,

  467.     ff_raw_write_packet,

  468.     .flags= AVFMT_NOTIMESTAMPS,

  469. };

  470. #endif

  471. 

  472. #if CONFIG_RAWVIDEO_DEMUXER

  473. AVInputFormat rawvideo_demuxer = {

  474.     "rawvideo",

  475.     NULL_IF_CONFIG_SMALL("raw video format"),

  476.     0,

  477.     NULL,

  478.     ff_raw_read_header,

  479.     rawvideo_read_packet,

  480.     .flags= AVFMT_GENERIC_INDEX,

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

  482.     .value = CODEC_ID_RAWVIDEO,

  483. };

  484. #endif

  485. 

  486. #if CONFIG_RAWVIDEO_MUXER

  487. AVOutputFormat rawvideo_muxer = {

  488.     "rawvideo",

  489.     NULL_IF_CONFIG_SMALL("raw video format"),

  490.     NULL,

  491.     "yuv,rgb",

  492.     0,

  493.     CODEC_ID_NONE,

  494.     CODEC_ID_RAWVIDEO,

  495.     NULL,

  496.     ff_raw_write_packet,

  497.     .flags= AVFMT_NOTIMESTAMPS,

  498. };

  499. #endif

  500. 

  501. #if CONFIG_SHORTEN_DEMUXER

  502. AVInputFormat shorten_demuxer = {

  503.     "shn",

  504.     NULL_IF_CONFIG_SMALL("raw Shorten"),

  505.     0,

  506.     NULL,

  507.     ff_raw_audio_read_header,

  508.     ff_raw_read_partial_packet,

  509.     .flags= AVFMT_GENERIC_INDEX,

  510.     .extensions = "shn",

  511.     .value = CODEC_ID_SHORTEN,

  512. };

  513. #endif

  514. 

  515. #if CONFIG_VC1_DEMUXER

  516. AVInputFormat vc1_demuxer = {

  517.     "vc1",

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

  519.     0,

  520.     NULL /* vc1_probe */,

  521.     ff_raw_video_read_header,

  522.     ff_raw_read_partial_packet,

  523.     .extensions = "vc1",

  524.     .value = CODEC_ID_VC1,

  525. };

  526. #endif