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/frame.h"
25 #include "libavutil/imgutils.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavformat/mux.h"
28 #include "avformat.h"
29 #include "internal.h"
30 
31 /* Identical to Adler32 when the type is uint8_t. */
32 #define DEFINE_CKSUM_LINE(name, type, conv) \
33 static void cksum_line_ ## name(unsigned *cksum, void *data, unsigned size) \
34 { \
35  type *p = data; \
36  unsigned a = *cksum & 0xFFFF, b = *cksum >> 16; \
37  for (; size > 0; size--, p++) { \
38  a = (a + (unsigned)(conv)) % 65521; \
39  b = (b + a) % 65521; \
40  } \
41  *cksum = a | (b << 16); \
42 }
43 
44 DEFINE_CKSUM_LINE(u8, uint8_t, *p)
45 DEFINE_CKSUM_LINE(s16, int16_t, *p + 0x8000)
46 DEFINE_CKSUM_LINE(s32, int32_t, *p + 0x80000000)
47 DEFINE_CKSUM_LINE(flt, float, *p * 0x80000000 + 0x80000000)
48 DEFINE_CKSUM_LINE(dbl, double, *p * 0x80000000 + 0x80000000)
49 
50 static void video_frame_cksum(AVBPrint *bp, AVFrame *frame)
51 {
53  int i, y;
54  uint8_t *data;
55  int linesize[5] = { 0 };
56 
57  av_bprintf(bp, ", %d x %d", frame->width, frame->height);
58  if (!desc) {
59  av_bprintf(bp, ", unknown");
60  return;
61  }
62  if (av_image_fill_linesizes(linesize, frame->format, frame->width) < 0)
63  return;
64  av_bprintf(bp, ", %s", desc->name);
65  for (i = 0; linesize[i]; i++) {
66  unsigned cksum = 0;
67  int h = frame->height;
68  if ((i == 1 || i == 2) && desc->nb_components >= 3)
69  h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
70  data = frame->data[i];
71  for (y = 0; y < h; y++) {
72  cksum = av_adler32_update(cksum, data, linesize[i]);
73  data += frame->linesize[i];
74  }
75  av_bprintf(bp, ", 0x%08x", cksum);
76  }
77 }
78 
79 static void audio_frame_cksum(AVBPrint *bp, AVFrame *frame)
80 {
81  int nb_planes, nb_samples, p;
82  const char *name;
83 
84  nb_planes = frame->ch_layout.nb_channels;
85  nb_samples = frame->nb_samples;
87  nb_samples *= nb_planes;
88  nb_planes = 1;
89  }
91  av_bprintf(bp, ", %d samples", frame->nb_samples);
92  av_bprintf(bp, ", %s", name ? name : "unknown");
93  for (p = 0; p < nb_planes; p++) {
94  uint32_t cksum = 0;
95  void *d = frame->extended_data[p];
96  switch (frame->format) {
97  case AV_SAMPLE_FMT_U8:
98  case AV_SAMPLE_FMT_U8P:
99  cksum_line_u8(&cksum, d, nb_samples);
100  break;
101  case AV_SAMPLE_FMT_S16:
102  case AV_SAMPLE_FMT_S16P:
103  cksum_line_s16(&cksum, d, nb_samples);
104  break;
105  case AV_SAMPLE_FMT_S32:
106  case AV_SAMPLE_FMT_S32P:
107  cksum_line_s32(&cksum, d, nb_samples);
108  break;
109  case AV_SAMPLE_FMT_FLT:
110  case AV_SAMPLE_FMT_FLTP:
111  cksum_line_flt(&cksum, d, nb_samples);
112  break;
113  case AV_SAMPLE_FMT_DBL:
114  case AV_SAMPLE_FMT_DBLP:
115  cksum_line_dbl(&cksum, d, nb_samples);
116  break;
117  default:
118  av_assert0(!"reached");
119  }
120  av_bprintf(bp, ", 0x%08"PRIx32, cksum);
121  }
122 }
123 
124 static int write_header(struct AVFormatContext *s)
125 {
127 }
128 
129 static int write_frame(struct AVFormatContext *s, int stream_index,
130  AVFrame **frame, unsigned flags)
131 {
132  AVBPrint bp;
133  int ret = 0;
134  enum AVMediaType type;
135  const char *type_name;
136 
138  return 0;
139 
141  av_bprintf(&bp, "%d, %10"PRId64"",
142  stream_index, (*frame)->pts);
143  type = s->streams[stream_index]->codecpar->codec_type;
144  type_name = av_get_media_type_string(type);
145  av_bprintf(&bp, ", %s", type_name ? type_name : "unknown");
146  switch (type) {
147  case AVMEDIA_TYPE_VIDEO:
148  video_frame_cksum(&bp, *frame);
149  break;
150  case AVMEDIA_TYPE_AUDIO:
151  audio_frame_cksum(&bp, *frame);
152  break;
153  }
154 
155  av_bprint_chars(&bp, '\n', 1);
156  if (av_bprint_is_complete(&bp))
157  avio_write(s->pb, bp.str, bp.len);
158  else
159  ret = AVERROR(ENOMEM);
160  av_bprint_finalize(&bp, NULL);
161  return ret;
162 }
163 
165 {
166  return AVERROR(ENOSYS);
167 }
168 
170  .p.name = "uncodedframecrc",
171  .p.long_name = NULL_IF_CONFIG_SMALL("uncoded framecrc testing"),
172  .p.audio_codec = AV_CODEC_ID_PCM_S16LE,
173  .p.video_codec = AV_CODEC_ID_RAWVIDEO,
176  .write_header = write_header,
177  .write_packet = write_packet,
178  .write_uncoded_frame = write_frame,
179 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
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:510
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:218
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_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:482
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AVFrame::width
int width
Definition: frame.h:412
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
data
const char data[16]
Definition: mxf.c:148
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:36
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:741
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:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_uncodedframecrc_muxer
const FFOutputFormat ff_uncodedframecrc_muxer
Definition: uncodedframecrcenc.c:169
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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:114
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:51
frame
static AVFrame * frame
Definition: demux_decode.c:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
write_frame
static int write_frame(struct AVFormatContext *s, int stream_index, AVFrame **frame, unsigned flags)
Definition: uncodedframecrcenc.c:129
NULL
#define NULL
Definition: coverity.c:32
FFOutputFormat
Definition: mux.h: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
write_packet
static int write_packet(struct AVFormatContext *s, AVPacket *pkt)
Definition: uncodedframecrcenc.c:164
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:106
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
frame.h
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:200
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
bprint.h
write_header
static int write_header(struct AVFormatContext *s)
Definition: uncodedframecrcenc.c:124
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AV_SAMPLE_FMT_U8
@ AV_SAMPLE_FMT_U8
unsigned 8 bits
Definition: samplefmt.h:57
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
AVFMT_TS_NEGATIVE
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:494
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:491
ret
ret
Definition: filter_design.txt:187
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
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:28
AVFrame::height
int height
Definition: frame.h:412
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
AV_WRITE_UNCODED_FRAME_QUERY
@ AV_WRITE_UNCODED_FRAME_QUERY
Query whether the feature is possible on this stream.
Definition: mux.h:210
desc
const char * desc
Definition: libsvtav1.c:73
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:79
DEFINE_CKSUM_LINE
#define DEFINE_CKSUM_LINE(name, type, conv)
Definition: uncodedframecrcenc.c:32
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:499
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:25
d
d
Definition: ffmpeg_filter.c:425
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
video_frame_cksum
static void video_frame_cksum(AVBPrint *bp, AVFrame *frame)
Definition: uncodedframecrcenc.c:50
h
h
Definition: vp9dsp_template.c:2038
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:61
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:145
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:59
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
mux.h