FFmpeg
uncodedframecrcenc.c
Go to the documentation of this file.
1 /*
2 * Copyright (c) 2013 Nicolas George
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 */
20 
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"
28 
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 }
41 
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)
47 
48 static void video_frame_cksum(AVBPrint *bp, AVFrame *frame)
49 {
51  int i, y;
52  uint8_t *data;
53  int linesize[5] = { 0 };
54 
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 }
76 
77 static void audio_frame_cksum(AVBPrint *bp, AVFrame *frame)
78 {
79  int nb_planes, nb_samples, p;
80  const char *name;
81 
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  }
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 {
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 
136  return 0;
137 
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 
163 {
164  return AVERROR(ENOSYS);
165 }
166 
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,
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:496
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:2564
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:470
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:303
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
s
#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:1109
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
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:218
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:495
i
#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:480
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:477
ff_uncodedframecrc_muxer
const AVOutputFormat ff_uncodedframecrc_muxer
Definition: uncodedframecrcenc.c:167
ret
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
Definition: samplefmt.h:70
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio_frame_cksum
static void audio_frame_cksum(AVBPrint *bp, AVFrame *frame)
Definition: uncodedframecrcenc.c:77
DEFINE_CKSUM_LINE
#define DEFINE_CKSUM_LINE(name, type, conv)
Definition: uncodedframecrcenc.c:30
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: internal.h:868
ff_framehash_write_header
int ff_framehash_write_header(AVFormatContext *s)
Set the timebase for each stream from the corresponding codec timebase and print it.
Definition: framehash.c:24
d
d
Definition: ffmpeg_filter.c:156
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
video_frame_cksum
static void video_frame_cksum(AVBPrint *bp, AVFrame *frame)
Definition: uncodedframecrcenc.c:48
h
h
Definition: vp9dsp_template.c:2038
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:64
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:139