FFmpeg: libavformat/rawdec.c Source File

FFmpeg

[フレーム]

libavformat

rawdec.c

Go to the documentation of this file.

1 /*

2 * RAW demuxers

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 */

23 #include "config_components.h"

25 #include "avformat.h"

26 #include "demux.h"

27 #include "internal.h"

28 #include "rawdec.h"

29 #include "libavutil/opt.h"

31 #define RAW_PACKET_SIZE 1024

33 int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)

34 {

35 FFRawDemuxerContext *raw = s->priv_data;

36 int ret, size;

38 size = raw->raw_packet_size;

40 if ((ret = av_new_packet(pkt, size)) < 0)

41 return ret;

43 pkt->pos= avio_tell(s->pb);

44 pkt->stream_index = 0;

45 ret = avio_read_partial(s->pb, pkt->data, size);

46 if (ret < 0) {

47 av_packet_unref(pkt);

48 return ret;

49 }

50 av_shrink_packet(pkt, ret);

51 return ret;

52 }

54 int ff_raw_audio_read_header(AVFormatContext *s)

55 {

56 AVStream *st = avformat_new_stream(s, NULL);

57 if (!st)

58 return AVERROR(ENOMEM);

59 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

60 st->codecpar->codec_id = ffifmt(s->iformat)->raw_codec_id;

61 ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL_RAW;

62 st->start_time = 0;

63 /* the parameters will be extracted from the compressed bitstream */

65 return 0;

66 }

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

69 int ff_raw_video_read_header(AVFormatContext *s)

70 {

71 AVStream *st;

72 FFStream *sti;

73 FFRawVideoDemuxerContext *s1 = s->priv_data;

74 int ret = 0;

77 st = avformat_new_stream(s, NULL);

78 if (!st) {

79 ret = AVERROR(ENOMEM);

80 goto fail;

81 }

82 sti = ffstream(st);

84 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

85 st->codecpar->codec_id = ffifmt(s->iformat)->raw_codec_id;

86 sti->need_parsing = AVSTREAM_PARSE_FULL_RAW;

88 st->avg_frame_rate = s1->framerate;

89 avpriv_set_pts_info(st, 64, 1, 1200000);

91 fail:

92 return ret;

93 }

95 int ff_raw_subtitle_read_header(AVFormatContext *s)

96 {

97 AVStream *st = avformat_new_stream(s, NULL);

98 if (!st)

99 return AVERROR(ENOMEM);

100 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;

101 st->codecpar->codec_id = ffifmt(s->iformat)->raw_codec_id;

102 st->start_time = 0;

103 return 0;

104 }

105

106 static int raw_data_read_header(AVFormatContext *s)

107 {

108 AVStream *st = avformat_new_stream(s, NULL);

109 if (!st)

110 return AVERROR(ENOMEM);

111 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;

112 st->codecpar->codec_id = ffifmt(s->iformat)->raw_codec_id;

113 st->start_time = 0;

114 return 0;

115 }

116

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

118

119 #define OFFSET(x) offsetof(FFRawVideoDemuxerContext, x)

120 #define DEC AV_OPT_FLAG_DECODING_PARAM

121 static const AVOption rawvideo_options[] = {

122 { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, DEC},

123 { "raw_packet_size", "", OFFSET(raw_packet_size), AV_OPT_TYPE_INT, {.i64 = RAW_PACKET_SIZE }, 1, INT_MAX, DEC},

124 { NULL },

125 };

126 #undef OFFSET

127

128 const AVClass ff_rawvideo_demuxer_class = {

129 .class_name = "generic raw video demuxer",

130 .item_name = av_default_item_name,

131 .option = rawvideo_options,

132 .version = LIBAVUTIL_VERSION_INT,

133 };

134

135 #define OFFSET(x) offsetof(FFRawDemuxerContext, x)

136 static const AVOption raw_options[] = {

137 { "raw_packet_size", "", OFFSET(raw_packet_size), AV_OPT_TYPE_INT, {.i64 = RAW_PACKET_SIZE }, 1, INT_MAX, DEC},

138 { NULL },

139 };

140

141 const AVClass ff_raw_demuxer_class = {

142 .class_name = "generic raw demuxer",

143 .item_name = av_default_item_name,

144 .option = raw_options,

145 .version = LIBAVUTIL_VERSION_INT,

146 };

147

148 #if CONFIG_DATA_DEMUXER

149 const FFInputFormat ff_data_demuxer = {

150 .p.name = "data",

151 .p.long_name = NULL_IF_CONFIG_SMALL("raw data"),

152 .p.flags = AVFMT_NOTIMESTAMPS,

153 .p.priv_class = &ff_raw_demuxer_class,

154 .read_header = raw_data_read_header,

155 .read_packet = ff_raw_read_partial_packet,

156 .raw_codec_id = AV_CODEC_ID_NONE,

157 .priv_data_size = sizeof(FFRawDemuxerContext),\

158 };

159 #endif

160

161 #if CONFIG_MJPEG_DEMUXER

162 static int mjpeg_probe(const AVProbeData *p)

163 {

164 int i;

165 int state = -1;

166 int nb_invalid = 0;

167 int nb_frames = 0;

168

169 for (i = 0; i < p->buf_size - 1; i++) {

170 int c;

171 if (p->buf[i] != 0xFF)

172 continue;

173 c = p->buf[i+1];

174 switch (c) {

175 case 0xD8:

176 state = 0xD8;

177 break;

178 case 0xC0:

179 case 0xC1:

180 case 0xC2:

181 case 0xC3:

182 case 0xC5:

183 case 0xC6:

184 case 0xC7:

185 case 0xF7:

186 if (state == 0xD8) {

187 state = 0xC0;

188 } else

189 nb_invalid++;

190 break;

191 case 0xDA:

192 if (state == 0xC0) {

193 state = 0xDA;

194 } else

195 nb_invalid++;

196 break;

197 case 0xD9:

198 if (state == 0xDA) {

199 state = 0xD9;

200 nb_frames++;

201 } else

202 nb_invalid++;

203 break;

204 default:

205 if ( (c >= 0x02 && c <= 0xBF)

206 || c == 0xC8) {

207 nb_invalid++;

208 }

209 }

210 }

211

212 if (nb_invalid*4 + 1 < nb_frames) {

213 static const char ct_jpeg[] = "\r\nContent-Type: image/jpeg\r\n";

214 int i;

215

216 for (i=0; i<FFMIN(p->buf_size - (int)sizeof(ct_jpeg), 100); i++)

217 if (!memcmp(p->buf + i, ct_jpeg, sizeof(ct_jpeg) - 1))

218 return AVPROBE_SCORE_EXTENSION;

219

220 if (nb_invalid == 0 && nb_frames > 2)

221 return AVPROBE_SCORE_EXTENSION / 2;

222 return AVPROBE_SCORE_EXTENSION / 4;

223 }

224 if (!nb_invalid && nb_frames)

225 return AVPROBE_SCORE_EXTENSION / 4;

226

227 return 0;

228 }

229

230 FF_DEF_RAWVIDEO_DEMUXER2(mjpeg, "raw MJPEG video", mjpeg_probe, "mjpg,mjpeg,mpo", AV_CODEC_ID_MJPEG, AVFMT_GENERIC_INDEX|AVFMT_NOTIMESTAMPS)

231 #endif

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:427

AVMEDIA_TYPE_SUBTITLE

@ AVMEDIA_TYPE_SUBTITLE

Definition: avutil.h:204

ff_raw_video_read_header

int ff_raw_video_read_header(AVFormatContext *s)

Definition: rawdec.c:69

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:51

ff_rawvideo_demuxer_class

const AVClass ff_rawvideo_demuxer_class

Definition: rawdec.c:128

raw_options

static const AVOption raw_options[]

Definition: rawdec.c:136

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

AV_OPT_TYPE_VIDEO_RATE

@ AV_OPT_TYPE_VIDEO_RATE

offset must point to AVRational

Definition: opt.h:248

AVFMT_NOTIMESTAMPS

#define AVFMT_NOTIMESTAMPS

Format does not need / have any timestamps.

Definition: avformat.h:479

AVPacket::data

uint8_t * data

Definition: packet.h:522

AVOption

AVOption.

Definition: opt.h:346

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:832

ff_raw_subtitle_read_header

int ff_raw_subtitle_read_header(AVFormatContext *s)

Definition: rawdec.c:95

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:454

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:853

ffstream

static av_always_inline FFStream * ffstream(AVStream *st)

Definition: internal.h:417

fail

#define fail()

Definition: checkasm.h:179

av_shrink_packet

void av_shrink_packet(AVPacket *pkt, int size)

Reduce packet size, correctly zeroing padding.

Definition: avpacket.c:113

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:494

FFRawDemuxerContext

Definition: rawdec.h:37

AVFMT_GENERIC_INDEX

#define AVFMT_GENERIC_INDEX

Use generic index building code.

Definition: avformat.h:480

rawvideo_options

static const AVOption rawvideo_options[]

Definition: rawdec.c:121

pkt

AVPacket * pkt

Definition: movenc.c:59

ff_raw_read_partial_packet

int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)

Definition: rawdec.c:33

#define s(width, name)

Definition: cbs_vp9.c:198

av_new_packet

int av_new_packet(AVPacket *pkt, int size)

Allocate the payload of a packet and initialize its fields with default values.

Definition: avpacket.c:98

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:553

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:453

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

#define s1

Definition: regdef.h:38

FFRawDemuxerContext::raw_packet_size

int raw_packet_size

Definition: rawdec.h:39

AVMEDIA_TYPE_DATA

@ AVMEDIA_TYPE_DATA

Opaque data information usually continuous.

Definition: avutil.h:203

FFStream::need_parsing

enum AVStreamParseType need_parsing

Definition: internal.h:386

ff_raw_demuxer_class

const AVClass ff_raw_demuxer_class

Definition: rawdec.c:141

AVFormatContext

Format I/O context.

Definition: avformat.h:1255

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:766

framerate

float framerate

Definition: av1_levels.c:29

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

rawdec.h

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

ff_raw_audio_read_header

int ff_raw_audio_read_header(AVFormatContext *s)

Definition: rawdec.c:54

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:451

RAW_PACKET_SIZE

#define RAW_PACKET_SIZE

Definition: rawdec.c:31

state

static struct @385 state

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

AVPROBE_SCORE_EXTENSION

#define AVPROBE_SCORE_EXTENSION

score for file extension

Definition: avformat.h:461

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:106

FFStream

Definition: internal.h:193

size