1/*
2 * Copyright (c) 2001 Fabrice Bellard
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 * THE SOFTWARE.
21 */
22
23#define MAX_SLICES 8
24
25#include "config.h"
26
27#include <stdio.h>
28#include <stdlib.h>
29#include <string.h>
30
31#if HAVE_UNISTD_H
32#include <unistd.h>
33#endif
34#if HAVE_IO_H
35#include <io.h>
36#endif
37#include <sys/types.h>
38#include <sys/stat.h>
39#include <fcntl.h>
40
41#include "libavcodec/avcodec.h"
42#include "libavutil/pixdesc.h"
43#include "libavutil/hash.h"
44#include "libavutil/bswap.h"
45
46static int header = 0;
47
48static int decode(AVCodecContext *dec_ctx, AVFrame *frame,
49           AVPacket *pkt)
50{
51    static uint64_t frame_cnt = 0;
52    int ret;
53
54    ret = avcodec_send_packet(dec_ctx, pkt);
55    if (ret < 0) {
56        fprintf(stderr, "Error sending a packet for decoding: %s\n", av_err2str(ret));
57        return ret;
58    }
59
60    while (ret >= 0) {
61        const AVPixFmtDescriptor *desc;
62        char sum[AV_HASH_MAX_SIZE * 2 + 1];
63        struct AVHashContext *hash;
64
65        ret = avcodec_receive_frame(dec_ctx, frame);
66        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
67            return 0;
68        } else if (ret < 0) {
69            fprintf(stderr, "Error during decoding: %s\n", av_err2str(ret));
70            return ret;
71        }
72
73        if (!header) {
74            printf(
75            "#format: frame checksums\n"
76            "#version: 2\n"
77            "#hash: MD5\n"
78            "#tb 0: 1/30\n"
79            "#media_type 0: video\n"
80            "#codec_id 0: rawvideo\n"
81            "#dimensions 0: 352x288\n"
82            "#sar 0: 128/117\n"
83            "#stream#, dts,        pts, duration,     size, hash\n");
84            header = 1;
85        }
86        desc = av_pix_fmt_desc_get(dec_ctx->pix_fmt);
87        if ((ret = av_hash_alloc(&hash, "md5")) < 0) {
88            return ret;
89        }
90        av_hash_init(hash);
91
92        for (int i = 0; i < frame->height; i++)
93            av_hash_update(hash, &frame->data[0][i * frame->linesize[0]], frame->width);
94        for (int i = 0; i < frame->height >> desc->log2_chroma_h; i++)
95            av_hash_update(hash, &frame->data[1][i * frame->linesize[1]], frame->width >> desc->log2_chroma_w);
96        for (int i = 0; i < frame->height >> desc->log2_chroma_h; i++)
97            av_hash_update(hash, &frame->data[2][i * frame->linesize[2]], frame->width >> desc->log2_chroma_w);
98
99        av_hash_final_hex(hash, sum, av_hash_get_size(hash) * 2 + 1);
100        printf("0, %10"PRId64", %10"PRId64",        1, %8d, %s\n",
101            frame_cnt, frame_cnt,
102            (frame->width * frame->height + 2 * (frame->height >> desc->log2_chroma_h) * (frame->width >> desc->log2_chroma_w)), sum);
103        frame_cnt += 1;
104        av_hash_freep(&hash);
105    }
106    return 0;
107}
108
109int main(int argc, char **argv)
110{
111    const AVCodec *codec = NULL;
112    AVCodecContext *c = NULL;
113    AVFrame *frame = NULL;
114    unsigned int threads;
115    AVPacket *pkt;
116    FILE *file = NULL;
117    char * nal = NULL;
118    int nals = 0, ret = 0;
119    char *p;
120
121    if (argc < 3) {
122        fprintf(stderr, "Usage: %s <threads> <input file>\n", argv[0]);
123        return -1;
124    }
125
126    if (!(threads = strtoul(argv[1], NULL, 0)))
127        threads = 1;
128    else if (threads > MAX_SLICES)
129        threads = MAX_SLICES;
130
131#ifdef _WIN32
132    setmode(fileno(stdout), O_BINARY);
133#endif
134
135    if (!(pkt = av_packet_alloc())) {
136        return -1;
137    }
138
139    nal = av_malloc(MAX_SLICES * UINT16_MAX + AV_INPUT_BUFFER_PADDING_SIZE);
140    if (!nal)
141        goto err;
142    p = nal;
143
144    if (!(codec = avcodec_find_decoder(AV_CODEC_ID_H264))) {
145        fprintf(stderr, "Codec not found\n");
146        ret = -1;
147        goto err;
148    }
149
150    if (!(c = avcodec_alloc_context3(codec))) {
151        fprintf(stderr, "Could not allocate video codec context\n");
152        ret = -1;
153        goto err;
154    }
155
156    c->width  = 352;
157    c->height = 288;
158
159    c->flags2 |= AV_CODEC_FLAG2_CHUNKS;
160    c->thread_type = FF_THREAD_SLICE;
161    c->thread_count = threads;
162
163    if ((ret = avcodec_open2(c, codec, NULL)) < 0) {
164        fprintf(stderr, "Could not open codec\n");
165        goto err;
166    }
167
168#if HAVE_THREADS
169    if (c->active_thread_type != FF_THREAD_SLICE) {
170        fprintf(stderr, "Couldn't activate slice threading: %d\n", c->active_thread_type);
171        ret = -1;
172        goto err;
173    }
174#else
175    fprintf(stderr, "WARN: not using threads, only checking decoding slice NALUs\n");
176#endif
177
178    if (!(frame = av_frame_alloc())) {
179        fprintf(stderr, "Could not allocate video frame\n");
180        ret = -1;
181        goto err;
182    }
183
184    if (!(file = fopen(argv[2], "rb"))) {
185        fprintf(stderr, "Couldn't open NALU file: %s\n", argv[2]);
186        ret = -1;
187        goto err;
188    }
189
190    while(1) {
191        uint16_t size = 0;
192        size_t ret = fread(&size, 1, sizeof(uint16_t), file);
193        if (ret != sizeof(uint16_t))
194            break;
195
196        size = av_be2ne16(size);
197        ret = fread(p, 1, size, file);
198        if (ret != size) {
199            perror("Couldn't read data");
200            goto err;
201        }
202        p += ret;
203
204        if (++nals >= threads) {
205            int decret = 0;
206            pkt->data = nal;
207            pkt->size = p - nal;
208            if ((decret = decode(c, frame, pkt)) < 0) {
209                goto err;
210            }
211            memset(nal, 0, MAX_SLICES * UINT16_MAX + AV_INPUT_BUFFER_PADDING_SIZE);
212            nals = 0;
213            p = nal;
214        }
215    }
216
217    if (nals) {
218        pkt->data = nal;
219        pkt->size = p - nal;
220        if ((ret = decode(c, frame, pkt)) < 0) {
221            goto err;
222        }
223    }
224
225    ret = decode(c, frame, NULL);
226
227err:
228    if (nal)
229        av_free(nal);
230    if (file)
231        fclose(file);
232    av_frame_free(&frame);
233    avcodec_free_context(&c);
234    av_packet_free(&pkt);
235
236    return ret;
237}
238