avformat/avienc: Store pal8 palette
[ffmpeg.git] / libavformat / md5enc.c
1 /*
2  * MD5 encoder (for codec/format testing)
3  * Copyright (c) 2009 Reimar Döffinger, based on crcenc (c) 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/avassert.h"
23 #include "libavutil/avstring.h"
24 #include "libavutil/hash.h"
25 #include "libavutil/opt.h"
26 #include "avformat.h"
27 #include "internal.h"
28
29 struct MD5Context {
30     const AVClass *avclass;
31     struct AVHashContext *hash;
32     char *hash_name;
33     int format_version;
34 };
35
36 static void md5_finish(struct AVFormatContext *s, char *buf)
37 {
38     struct MD5Context *c = s->priv_data;
39     uint8_t md5[AV_HASH_MAX_SIZE];
40     int i, offset = strlen(buf);
41     int len = av_hash_get_size(c->hash);
42     av_assert0(len > 0 && len <= sizeof(md5));
43     av_hash_final(c->hash, md5);
44     for (i = 0; i < len; i++) {
45         snprintf(buf + offset, 3, "%02"PRIx8, md5[i]);
46         offset += 2;
47     }
48     buf[offset] = '\n';
49     buf[offset+1] = 0;
50
51     avio_write(s->pb, buf, strlen(buf));
52     avio_flush(s->pb);
53 }
54
55 #define OFFSET(x) offsetof(struct MD5Context, x)
56 #define ENC AV_OPT_FLAG_ENCODING_PARAM
57 static const AVOption hash_options[] = {
58     { "hash", "set hash to use", OFFSET(hash_name), AV_OPT_TYPE_STRING, {.str = "md5"}, 0, 0, ENC },
59     { "format_version", "file format version", OFFSET(format_version), AV_OPT_TYPE_INT, {.i64 = 1}, 1, 1, ENC },
60     { NULL },
61 };
62
63 static const AVClass md5enc_class = {
64     .class_name = "hash encoder class",
65     .item_name  = av_default_item_name,
66     .option     = hash_options,
67     .version    = LIBAVUTIL_VERSION_INT,
68 };
69
70 #if CONFIG_MD5_MUXER
71 static int write_header(struct AVFormatContext *s)
72 {
73     struct MD5Context *c = s->priv_data;
74     int res = av_hash_alloc(&c->hash, c->hash_name);
75     if (res < 0)
76         return res;
77     av_hash_init(c->hash);
78     return 0;
79 }
80
81 static int write_packet(struct AVFormatContext *s, AVPacket *pkt)
82 {
83     struct MD5Context *c = s->priv_data;
84     av_hash_update(c->hash, pkt->data, pkt->size);
85     return 0;
86 }
87
88 static int write_trailer(struct AVFormatContext *s)
89 {
90     struct MD5Context *c = s->priv_data;
91     char buf[256];
92     av_strlcpy(buf, av_hash_get_name(c->hash), sizeof(buf) - 200);
93     av_strlcat(buf, "=", sizeof(buf) - 200);
94
95     md5_finish(s, buf);
96
97     av_hash_freep(&c->hash);
98     return 0;
99 }
100
101 AVOutputFormat ff_md5_muxer = {
102     .name              = "md5",
103     .long_name         = NULL_IF_CONFIG_SMALL("MD5 testing"),
104     .priv_data_size    = sizeof(struct MD5Context),
105     .audio_codec       = AV_CODEC_ID_PCM_S16LE,
106     .video_codec       = AV_CODEC_ID_RAWVIDEO,
107     .write_header      = write_header,
108     .write_packet      = write_packet,
109     .write_trailer     = write_trailer,
110     .flags             = AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT |
111                          AVFMT_TS_NEGATIVE,
112     .priv_class        = &md5enc_class,
113 };
114 #endif
115
116 #if CONFIG_FRAMEMD5_MUXER
117 static int framemd5_write_header(struct AVFormatContext *s)
118 {
119     struct MD5Context *c = s->priv_data;
120     int res = av_hash_alloc(&c->hash, c->hash_name);
121     if (res < 0)
122         return res;
123     avio_printf(s->pb, "#format: frame checksums\n");
124     avio_printf(s->pb, "#version: %d\n", c->format_version);
125     avio_printf(s->pb, "#hash: %s\n", av_hash_get_name(c->hash));
126     ff_framehash_write_header(s);
127     avio_printf(s->pb, "#stream#, dts,        pts, duration,     size, hash\n");
128     return 0;
129 }
130
131 static int framemd5_write_packet(struct AVFormatContext *s, AVPacket *pkt)
132 {
133     struct MD5Context *c = s->priv_data;
134     char buf[256];
135     av_hash_init(c->hash);
136     av_hash_update(c->hash, pkt->data, pkt->size);
137
138     snprintf(buf, sizeof(buf) - 64, "%d, %10"PRId64", %10"PRId64", %8"PRId64", %8d, ",
139              pkt->stream_index, pkt->dts, pkt->pts, pkt->duration, pkt->size);
140     md5_finish(s, buf);
141     return 0;
142 }
143
144 static int framemd5_write_trailer(struct AVFormatContext *s)
145 {
146     struct MD5Context *c = s->priv_data;
147     av_hash_freep(&c->hash);
148     return 0;
149 }
150
151 static const AVClass framemd5_class = {
152     .class_name = "frame hash encoder class",
153     .item_name  = av_default_item_name,
154     .option     = hash_options,
155     .version    = LIBAVUTIL_VERSION_INT,
156 };
157
158 AVOutputFormat ff_framemd5_muxer = {
159     .name              = "framemd5",
160     .long_name         = NULL_IF_CONFIG_SMALL("Per-frame MD5 testing"),
161     .priv_data_size    = sizeof(struct MD5Context),
162     .audio_codec       = AV_CODEC_ID_PCM_S16LE,
163     .video_codec       = AV_CODEC_ID_RAWVIDEO,
164     .write_header      = framemd5_write_header,
165     .write_packet      = framemd5_write_packet,
166     .write_trailer     = framemd5_write_trailer,
167     .flags             = AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT |
168                          AVFMT_TS_NEGATIVE,
169     .priv_class        = &framemd5_class,
170 };
171 #endif