FFmpeg: libavformat/uncodedframecrcenc.c Source File

FFmpeg

[フレーム]

libavformat

uncodedframecrcenc.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public License

8 * as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14 * GNU Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public License

17 * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,

18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #include "libavutil/adler32.h"

22 #include "libavutil/avassert.h"

23 #include "libavutil/bprint.h"

24 #include "libavutil/imgutils.h"

25 #include "libavutil/pixdesc.h"

26 #include "avformat.h"

27 #include "internal.h"

29 /* Identical to Adler32 when the type is uint8_t. */

30 #define DEFINE_CKSUM_LINE(name, type, conv) \

31 static void cksum_line_ ## name(unsigned *cksum, void *data, unsigned size) \

32 { \

33 type *p = data; \

34 unsigned a = *cksum & 0xFFFF, b = *cksum >> 16; \

35 for (; size > 0; size--, p++) { \

36 a = (a + (unsigned)(conv)) % 65521; \

37 b = (b + a) % 65521; \

38 } \

39 *cksum = a | (b << 16); \

40 }

42 DEFINE_CKSUM_LINE(u8, uint8_t, *p)

43 DEFINE_CKSUM_LINE(s16, int16_t, *p + 0x8000)

44 DEFINE_CKSUM_LINE(s32, int32_t, *p + 0x80000000)

45 DEFINE_CKSUM_LINE(flt, float, *p * 0x80000000 + 0x80000000)

46 DEFINE_CKSUM_LINE(dbl, double, *p * 0x80000000 + 0x80000000)

48 static void video_frame_cksum(AVBPrint *bp, AVFrame *frame)

49 {

50 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);

51 int i, y;

52 uint8_t *data;

53 int linesize[5] = { 0 };

55 av_bprintf(bp, ", %d x %d", frame->width, frame->height);

56 if (!desc) {

57 av_bprintf(bp, ", unknown");

58 return;

59 }

60 if (av_image_fill_linesizes(linesize, frame->format, frame->width) < 0)

61 return;

62 av_bprintf(bp, ", %s", desc->name);

63 for (i = 0; linesize[i]; i++) {

64 unsigned cksum = 0;

65 int h = frame->height;

66 if ((i == 1 || i == 2) && desc->nb_components >= 3)

67 h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);

68 data = frame->data[i];

69 for (y = 0; y < h; y++) {

70 cksum = av_adler32_update(cksum, data, linesize[i]);

71 data += frame->linesize[i];

72 }

73 av_bprintf(bp, ", 0x%08x", cksum);

74 }

75 }

77 static void audio_frame_cksum(AVBPrint *bp, AVFrame *frame)

78 {

79 int nb_planes, nb_samples, p;

80 const char *name;

82 nb_planes = frame->channels;

83 nb_samples = frame->nb_samples;

84 if (!av_sample_fmt_is_planar(frame->format)) {

85 nb_samples *= nb_planes;

86 nb_planes = 1;

87 }

88 name = av_get_sample_fmt_name(frame->format);

89 av_bprintf(bp, ", %d samples", frame->nb_samples);

90 av_bprintf(bp, ", %s", name ? name : "unknown");

91 for (p = 0; p < nb_planes; p++) {

92 uint32_t cksum = 0;

93 void *d = frame->extended_data[p];

94 switch (frame->format) {

95 case AV_SAMPLE_FMT_U8:

96 case AV_SAMPLE_FMT_U8P:

97 cksum_line_u8(&cksum, d, nb_samples);

98 break;

99 case AV_SAMPLE_FMT_S16:

100 case AV_SAMPLE_FMT_S16P:

101 cksum_line_s16(&cksum, d, nb_samples);

102 break;

103 case AV_SAMPLE_FMT_S32:

104 case AV_SAMPLE_FMT_S32P:

105 cksum_line_s32(&cksum, d, nb_samples);

106 break;

107 case AV_SAMPLE_FMT_FLT:

108 case AV_SAMPLE_FMT_FLTP:

109 cksum_line_flt(&cksum, d, nb_samples);

110 break;

111 case AV_SAMPLE_FMT_DBL:

112 case AV_SAMPLE_FMT_DBLP:

113 cksum_line_dbl(&cksum, d, nb_samples);

114 break;

115 default:

116 av_assert0(!"reached");

117 }

118 av_bprintf(bp, ", 0x%08"PRIx32, cksum);

119 }

120 }

121

122 static int write_header(struct AVFormatContext *s)

123 {

124 return ff_framehash_write_header(s);

125 }

126

127 static int write_frame(struct AVFormatContext *s, int stream_index,

128 AVFrame **frame, unsigned flags)

129 {

130 AVBPrint bp;

131 int ret = 0;

132 enum AVMediaType type;

133 const char *type_name;

134

135 if ((flags & AV_WRITE_UNCODED_FRAME_QUERY))

136 return 0;

137

138 av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);

139 av_bprintf(&bp, "%d, %10"PRId64"",

140 stream_index, (*frame)->pts);

141 type = s->streams[stream_index]->codecpar->codec_type;

142 type_name = av_get_media_type_string(type);

143 av_bprintf(&bp, ", %s", type_name ? type_name : "unknown");

144 switch (type) {

145 case AVMEDIA_TYPE_VIDEO:

146 video_frame_cksum(&bp, *frame);

147 break;

148 case AVMEDIA_TYPE_AUDIO:

149 audio_frame_cksum(&bp, *frame);

150 break;

151 }

152

153 av_bprint_chars(&bp, '\n', 1);

154 if (av_bprint_is_complete(&bp))

155 avio_write(s->pb, bp.str, bp.len);

156 else

157 ret = AVERROR(ENOMEM);

158 av_bprint_finalize(&bp, NULL);

159 return ret;

160 }

161

162 static int write_packet(struct AVFormatContext *s, AVPacket *pkt)

163 {

164 return AVERROR(ENOSYS);

165 }

166

167 const AVOutputFormat ff_uncodedframecrc_muxer = {

168 .name = "uncodedframecrc",

169 .long_name = NULL_IF_CONFIG_SMALL("uncoded framecrc testing"),

170 .audio_codec = AV_CODEC_ID_PCM_S16LE,

171 .video_codec = AV_CODEC_ID_RAWVIDEO,

172 .write_header = write_header,

173 .write_packet = write_packet,

174 .write_uncoded_frame = write_frame,

175 .flags = AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT |

176 AVFMT_TS_NEGATIVE,

177 };

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:314

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:69

AV_BPRINT_SIZE_UNLIMITED

#define AV_BPRINT_SIZE_UNLIMITED

name

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name

Definition: writing_filters.txt:88

AVOutputFormat::name

const char * name

Definition: avformat.h:504

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

av_bprint_finalize

int av_bprint_finalize(AVBPrint *buf, char **ret_str)

Finalize a print buffer.

Definition: bprint.c:234

av_bprint_init

void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)

Definition: bprint.c:68

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2660

AVFMT_VARIABLE_FPS

#define AVFMT_VARIABLE_FPS

Format allows variable fps.

Definition: avformat.h:478

AV_CODEC_ID_RAWVIDEO

@ AV_CODEC_ID_RAWVIDEO

Definition: codec_id.h:63

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:317

pixdesc.h

AV_SAMPLE_FMT_S32P

@ AV_SAMPLE_FMT_S32P

signed 32 bits, planar

Definition: samplefmt.h:68

data

const char data[16]

Definition: mxf.c:143

type

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type

Definition: writing_filters.txt:86

avassert.h

pkt

AVPacket * pkt

Definition: movenc.c:59

av_image_fill_linesizes

int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)

Fill plane linesizes for an image with pixel format pix_fmt and width width.

Definition: imgutils.c:89

#define s(width, name)

Definition: cbs_vp9.c:257

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:51

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

av_sample_fmt_is_planar

int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)

Check if the sample format is planar.

Definition: samplefmt.c:112

av_get_sample_fmt_name

const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)

Return the name of sample_fmt, or NULL if sample_fmt is not recognized.

Definition: samplefmt.c:49

AVFormatContext

Format I/O context.

Definition: avformat.h:1200

internal.h

write_frame

static int write_frame(struct AVFormatContext *s, int stream_index, AVFrame **frame, unsigned flags)

Definition: uncodedframecrcenc.c:127

NULL

#define NULL

Definition: coverity.c:32

adler32.h

av_adler32_update

AVAdler av_adler32_update(AVAdler adler, const uint8_t *buf, size_t len)

Calculate the Adler32 checksum of a buffer.

Definition: adler32.c:44

av_bprint_is_complete

static int av_bprint_is_complete(const AVBPrint *buf)

Test if the print buffer is complete (not truncated).

Definition: bprint.h:185

write_packet

static int write_packet(struct AVFormatContext *s, AVPacket *pkt)

Definition: uncodedframecrcenc.c:162

AVMediaType

Definition: avutil.h:199

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:117

AV_SAMPLE_FMT_U8P

@ AV_SAMPLE_FMT_U8P

unsigned 8 bits, planar

Definition: samplefmt.h:66

avio_write

void avio_write(AVIOContext *s, const unsigned char *buf, int size)

Definition: aviobuf.c:232

AV_SAMPLE_FMT_S16P

@ AV_SAMPLE_FMT_S16P

signed 16 bits, planar

Definition: samplefmt.h:67

bprint.h

write_header

static int write_header(struct AVFormatContext *s)

Definition: uncodedframecrcenc.c:122

AVOutputFormat

Definition: avformat.h:503

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:271

AV_SAMPLE_FMT_U8

@ AV_SAMPLE_FMT_U8

unsigned 8 bits

Definition: samplefmt.h:60

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:61

AVFMT_TS_NEGATIVE

#define AVFMT_TS_NEGATIVE

Format allows muxing negative timestamps.

Definition: avformat.h:488

AVFMT_TS_NONSTRICT

#define AVFMT_TS_NONSTRICT

Format does not require strictly increasing timestamps, but they must still be monotonic.

Definition: avformat.h:485

ff_uncodedframecrc_muxer

const AVOutputFormat ff_uncodedframecrc_muxer

Definition: uncodedframecrcenc.c:167

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

avformat.h

av_bprintf

void av_bprintf(AVBPrint *buf, const char *fmt,...)

Definition: bprint.c:93

av_get_media_type_string

const char * av_get_media_type_string(enum AVMediaType media_type)

Return a string describing the media_type enum, NULL if media_type is unknown.

Definition: utils.c:71

AV_SAMPLE_FMT_DBLP

@ AV_SAMPLE_FMT_DBLP

double, planar