> seems to break > make fate-vsynth1-mjpeg-444 Fixed.pull/252/head
Jerry Jiang
8 years ago
committed by
Rostislav Pehlivanov
parent
2d453188c2
commit
884506dfe2
23 changed files with 914 additions and 96 deletions
@ -0,0 +1,195 @@ |
||||
/*
|
||||
* MJPEG encoder |
||||
* Copyright (c) 2016 William Ma, Ted Ying, Jerry Jiang |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
#include <string.h> |
||||
#include <stdint.h> |
||||
#include <assert.h> |
||||
#include <stdlib.h> |
||||
#include "libavutil/common.h" |
||||
#include "libavutil/error.h" |
||||
#include "libavutil/qsort.h" |
||||
#include "mjpegenc_huffman.h" |
||||
|
||||
/**
|
||||
* Comparison function for two PTables by prob |
||||
* |
||||
* @param a First PTable to compare |
||||
* @param b Second PTable to compare |
||||
* @return < 0 for less than, 0 for equals, > 0 for greater than |
||||
*/ |
||||
static int compare_by_prob(const void *a, const void *b) |
||||
{ |
||||
PTable a_val = *(PTable *) a; |
||||
PTable b_val = *(PTable *) b; |
||||
return a_val.prob - b_val.prob; |
||||
} |
||||
|
||||
/**
|
||||
* Comparison function for two HuffTables by length |
||||
* |
||||
* @param a First HuffTable to compare |
||||
* @param b Second HuffTable to compare |
||||
* @return < 0 for less than, 0 for equals, > 0 for greater than |
||||
*/ |
||||
static int compare_by_length(const void *a, const void *b) |
||||
{ |
||||
HuffTable a_val = *(HuffTable *) a; |
||||
HuffTable b_val = *(HuffTable *) b; |
||||
return a_val.length - b_val.length; |
||||
} |
||||
|
||||
/**
|
||||
* Computes the length of the Huffman encoding for each distinct input value. |
||||
* Uses package merge algorithm as follows: |
||||
* 1. start with an empty list, lets call it list(0), set i = 0 |
||||
* 2. add 1 entry to list(i) for each symbol we have and give each a score equal to the probability of the respective symbol |
||||
* 3. merge the 2 symbols of least score and put them in list(i+1), and remove them from list(i). The new score will be the sum of the 2 scores |
||||
* 4. if there is more than 1 symbol left in the current list(i), then goto 3 |
||||
* 5. i++ |
||||
* 6. if i < 16 goto 2 |
||||
* 7. select the n-1 elements in the last list with the lowest score (n = the number of symbols) |
||||
* 8. the length of the huffman code for symbol s will be equal to the number of times the symbol occurs in the select elements |
||||
* Go to guru.multimedia.cx/small-tasks-for-ffmpeg/ for more details |
||||
* |
||||
* All probabilities should be positive integers. The output is sorted by code, |
||||
* not by length. |
||||
* |
||||
* @param prob_table input array of a PTable for each distinct input value |
||||
* @param distincts output array of a HuffTable that will be populated by this function |
||||
* @param size size of the prob_table array |
||||
* @param max_length max length of an encoding |
||||
*/ |
||||
void ff_mjpegenc_huffman_compute_bits(PTable *prob_table, HuffTable *distincts, int size, int max_length) |
||||
{ |
||||
PackageMergerList list_a, list_b, *to = &list_a, *from = &list_b, *temp; |
||||
|
||||
int times, i, j, k; |
||||
|
||||
int nbits[257] = {0}; |
||||
|
||||
int min; |
||||
|
||||
to->nitems = 0; |
||||
from->nitems = 0; |
||||
to->item_idx[0] = 0; |
||||
from->item_idx[0] = 0; |
||||
AV_QSORT(prob_table, size, PTable, compare_by_prob); |
||||
|
||||
for (times = 0; times <= max_length; times++) { |
||||
to->nitems = 0; |
||||
to->item_idx[0] = 0; |
||||
|
||||
j = 0; |
||||
k = 0; |
||||
|
||||
if (times < max_length) { |
||||
i = 0; |
||||
} |
||||
while (i < size || j + 1 < from->nitems) { |
||||
to->nitems++; |
||||
to->item_idx[to->nitems] = to->item_idx[to->nitems - 1]; |
||||
if (i < size && |
||||
(j + 1 >= from->nitems || |
||||
prob_table[i].prob < |
||||
from->probability[j] + from->probability[j + 1])) { |
||||
to->items[to->item_idx[to->nitems]++] = prob_table[i].value; |
||||
to->probability[to->nitems - 1] = prob_table[i].prob; |
||||
i++; |
||||
} else { |
||||
for (k = from->item_idx[j]; k < from->item_idx[j + 2]; k++) { |
||||
to->items[to->item_idx[to->nitems]++] = from->items[k]; |
||||
} |
||||
to->probability[to->nitems - 1] = |
||||
from->probability[j] + from->probability[j + 1]; |
||||
j += 2; |
||||
} |
||||
} |
||||
temp = to; |
||||
to = from; |
||||
from = temp; |
||||
} |
||||
|
||||
min = (size - 1 < from->nitems) ? size - 1 : from->nitems; |
||||
for (i = 0; i < from->item_idx[min]; i++) { |
||||
nbits[from->items[i]]++; |
||||
} |
||||
// we don't want to return the 256 bit count (it was just in here to prevent
|
||||
// all 1s encoding)
|
||||
j = 0; |
||||
for (i = 0; i < 256; i++) { |
||||
if (nbits[i] > 0) { |
||||
distincts[j].code = i; |
||||
distincts[j].length = nbits[i]; |
||||
j++; |
||||
} |
||||
} |
||||
} |
||||
|
||||
void ff_mjpeg_encode_huffman_init(MJpegEncHuffmanContext *s) |
||||
{ |
||||
memset(s->val_count, 0, sizeof(s->val_count)); |
||||
} |
||||
|
||||
/**
|
||||
* Produces a Huffman encoding with a given input |
||||
* |
||||
* @param s input to encode |
||||
* @param bits output array where the ith character represents how many input values have i length encoding |
||||
* @param val output array of input values sorted by their encoded length |
||||
* @param max_nval maximum number of distinct input values |
||||
* @return int Return code, 0 if succeeded. |
||||
*/ |
||||
int ff_mjpeg_encode_huffman_close(MJpegEncHuffmanContext *s, uint8_t bits[17], |
||||
uint8_t val[], int max_nval) |
||||
{ |
||||
int i, j; |
||||
int nval = 0; |
||||
PTable val_counts[257]; |
||||
HuffTable distincts[256]; |
||||
|
||||
for (i = 0; i < 256; i++) { |
||||
if (s->val_count[i]) nval++; |
||||
} |
||||
if (nval > max_nval) { |
||||
return AVERROR(EINVAL); |
||||
} |
||||
|
||||
j = 0; |
||||
for (i = 0; i < 256; i++) { |
||||
if (s->val_count[i]) { |
||||
val_counts[j].value = i; |
||||
val_counts[j].prob = s->val_count[i]; |
||||
j++; |
||||
} |
||||
} |
||||
val_counts[j].value = 256; |
||||
val_counts[j].prob = 0; |
||||
ff_mjpegenc_huffman_compute_bits(val_counts, distincts, nval + 1, 16); |
||||
AV_QSORT(distincts, nval, HuffTable, compare_by_length); |
||||
|
||||
memset(bits, 0, sizeof(bits[0]) * 17); |
||||
for (i = 0; i < nval; i++) { |
||||
val[i] = distincts[i].code; |
||||
bits[distincts[i].length]++; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,74 @@ |
||||
/*
|
||||
* MJPEG encoder |
||||
* Copyright (c) 2016 William Ma, Ted Ying, Jerry Jiang |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
/**
|
||||
* @file |
||||
* Huffman table generation for MJPEG encoder. |
||||
*/ |
||||
|
||||
#ifndef AVCODEC_MJPEGENC_HUFFMAN_H |
||||
#define AVCODEC_MJPEGENC_HUFFMAN_H |
||||
|
||||
typedef struct MJpegEncHuffmanContext { |
||||
int val_count[256]; |
||||
} MJpegEncHuffmanContext; |
||||
|
||||
// Uses the package merge algorithm to compute the Huffman table.
|
||||
void ff_mjpeg_encode_huffman_init(MJpegEncHuffmanContext *s); |
||||
static inline void ff_mjpeg_encode_huffman_increment(MJpegEncHuffmanContext *s, |
||||
uint8_t val) |
||||
{ |
||||
s->val_count[val]++; |
||||
} |
||||
int ff_mjpeg_encode_huffman_close(MJpegEncHuffmanContext *s, |
||||
uint8_t bits[17], uint8_t val[], |
||||
int max_nval); |
||||
|
||||
|
||||
/**
|
||||
* Used to assign a occurrence count or "probability" to an input value |
||||
*/ |
||||
typedef struct PTable { |
||||
int value; ///< input value
|
||||
int prob; ///< number of occurences of this value in input
|
||||
} PTable; |
||||
|
||||
/**
|
||||
* Used to store intermediate lists in the package merge algorithm |
||||
*/ |
||||
typedef struct PackageMergerList { |
||||
int nitems; ///< number of items in the list and probability ex. 4
|
||||
int item_idx[515]; ///< index range for each item in items 0, 2, 5, 9, 13
|
||||
int probability[514]; ///< probability of each item 3, 8, 18, 46
|
||||
int items[257 * 16]; ///< chain of all individual values that make up items A, B, A, B, C, A, B, C, D, C, D, D, E
|
||||
} PackageMergerList; |
||||
|
||||
/**
|
||||
* Used to store optimal huffman encoding results |
||||
*/ |
||||
typedef struct HuffTable { |
||||
int code; ///< code is the input value
|
||||
int length; ///< length of the encoding
|
||||
} HuffTable; |
||||
|
||||
void ff_mjpegenc_huffman_compute_bits(PTable *prob_table, HuffTable *distincts, |
||||
int size, int max_length); |
||||
#endif /* AVCODEC_MJPEGENC_HUFFMAN_H */ |
||||
@ -0,0 +1,163 @@ |
||||
/*
|
||||
* Copyright (c) 2016 William Ma, Sofia Kim, Dustin Woo |
||||
* |
||||
* This file is part of FFmpeg. |
||||
* |
||||
* FFmpeg is free software; you can redistribute it and/or |
||||
* modify it under the terms of the GNU Lesser General Public |
||||
* License as published by the Free Software Foundation; either |
||||
* version 2.1 of the License, or (at your option) any later version. |
||||
* |
||||
* FFmpeg is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* Lesser General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with FFmpeg; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||||
*/ |
||||
|
||||
/**
|
||||
* @file |
||||
* Optimal Huffman Encoding tests. |
||||
*/ |
||||
|
||||
#include "libavcodec/avcodec.h" |
||||
#include <stdlib.h> |
||||
#include "libavcodec/mjpegenc.h" |
||||
#include "libavcodec/mjpegenc_huffman.h" |
||||
#include "libavcodec/mjpegenc_common.h" |
||||
#include "libavcodec/mpegvideo.h" |
||||
|
||||
// Validate the computed lengths satisfy the JPEG restrictions and is optimal.
|
||||
static int check_lengths(int L, int expected_length, |
||||
const int *probs, int nprobs) |
||||
{ |
||||
HuffTable lengths[256]; |
||||
PTable val_counts[256]; |
||||
int actual_length = 0, i, j, k, prob, length; |
||||
int ret = 0; |
||||
double cantor_measure = 0; |
||||
assert(nprobs <= 256); |
||||
|
||||
for (i = 0; i < nprobs; i++) { |
||||
val_counts[i] = (PTable){.value = i, .prob = probs[i]}; |
||||
} |
||||
|
||||
ff_mjpegenc_huffman_compute_bits(val_counts, lengths, nprobs, L); |
||||
|
||||
for (i = 0; i < nprobs; i++) { |
||||
// Find the value's prob and length
|
||||
for (j = 0; j < nprobs; j++) |
||||
if (val_counts[j].value == i) break; |
||||
for (k = 0; k < nprobs; k++) |
||||
if (lengths[k].code == i) break; |
||||
if (!(j < nprobs && k < nprobs)) return 1; |
||||
prob = val_counts[j].prob; |
||||
length = lengths[k].length; |
||||
|
||||
if (prob) { |
||||
actual_length += prob * length; |
||||
cantor_measure += 1. / (1 << length); |
||||
} |
||||
|
||||
if (length > L || length < 1) return 1; |
||||
} |
||||
// Check that the codes can be prefix-free.
|
||||
if (cantor_measure > 1) ret = 1; |
||||
// Check that the total length is optimal
|
||||
if (actual_length != expected_length) ret = 1; |
||||
|
||||
if (ret == 1) { |
||||
fprintf(stderr, |
||||
"Cantor measure: %f\n" |
||||
"Actual length: %d\n" |
||||
"Expected length: %d\n", |
||||
cantor_measure, actual_length, expected_length); |
||||
} |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
static const int probs_zeroes[] = {6, 6, 0, 0, 0}; |
||||
static const int probs_skewed[] = {2, 0, 0, 0, 0, 1, 0, 0, 20, 0, 2, |
||||
0, 10, 5, 1, 1, 9, 1, 1, 6, 0, 5, 0, 1, 0, 7, 6, 1, 1, 5, 0, 0, 0, 0, |
||||
11, 0, 0, 0, 51, 1, 0, 20, 0, 1, 0, 0, 0, 0, 6, 106, 1, 0, 1, 0, 2, 1, |
||||
16, 0, 0, 5, 0, 0, 0, 4, 3, 15, 4, 4, 0, 0, 0, 3, 0, 0, 1, 0, 3, 0, 3, |
||||
2, 2, 0, 0, 4, 3, 40, 1, 2, 0, 22, 0, 0, 0, 9, 0, 0, 0, 0, 1, 1, 0, 1, |
||||
6, 11, 4, 10, 28, 6, 1, 0, 0, 9, 9, 4, 0, 0, 0, 0, 8, 33844, 2, 0, 2, |
||||
1, 1, 5, 0, 0, 1, 9, 1, 0, 4, 14, 4, 0, 0, 3, 8, 0, 51, 9, 6, 1, 1, 2, |
||||
2, 3, 1, 5, 5, 29, 0, 0, 0, 0, 14, 29, 6, 4, 13, 12, 2, 3, 1, 0, 5, 4, |
||||
1, 1, 0, 0, 29, 1, 0, 0, 0, 0, 4, 0, 0, 1, 0, 1, 7, 0, 42, 0, 0, 0, 0, |
||||
0, 2, 0, 3, 9, 0, 0, 0, 2, 1, 0, 0, 6, 5, 6, 1, 2, 3, 0, 0, 0, 3, 0, 0, |
||||
28, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 23, 0, 0, 0, 0, |
||||
0, 21, 1, 0, 3, 24, 2, 0, 0, 7, 0, 0, 1, 5, 1, 2, 0, 5}; |
||||
static const int probs_sat[] = {74, 8, 14, 7, 9345, 40, 0, 2014, 2, 1, |
||||
115, 0, 2, 1, 194, 388, 20, 0, 0, 2, 1, 121, 1, 1583, 0, 16, 21, 2, 132, |
||||
2, 15, 9, 13, 1, 0, 2293, 2, 8, 5, 2, 30, 0, 0, 4, 54, 783, 4, 1, 2, 4, |
||||
0, 22, 93, 1, 143, 19, 0, 36, 32, 4, 6, 33, 3, 45, 0, 8, 1, 0, 18, 17, 1, |
||||
0, 1, 0, 0, 1, 1004, 38, 3, 8, 90, 23, 0, 2819, 3, 0, 970, 158, 9, 6, 4, |
||||
48, 4, 0, 1, 0, 0, 60, 3, 62, 0, 2, 2, 2, 279, 66, 16, 1, 20, 0, 7, 9, |
||||
32, 1411, 6, 3, 27, 1, 5, 49, 0, 0, 0, 0, 0, 2, 10, 1, 1, 2, 3, 801, 3, |
||||
25, 5, 1, 1, 0, 632, 0, 14, 18, 5, 8, 200, 4, 4, 22, 12, 0, 4, 1, 0, 2, |
||||
4, 9, 3, 16, 7, 2, 2, 213, 0, 2, 620, 39303, 0, 1, 0, 2, 1, 183781, 1, |
||||
0, 0, 0, 94, 7, 3, 4, 0, 4, 306, 43, 352, 76, 34, 13, 11, 0, 51, 1, 13, |
||||
19, 0, 26, 0, 7276, 4, 207, 31, 1, 2, 4, 6, 19, 8, 17, 4, 6, 0, 1085, 0, |
||||
0, 0, 3, 489, 36, 1, 0, 1, 9420, 294, 28, 0, 57, 5, 0, 9, 2, 0, 1, 2, 2, |
||||
0, 0, 9, 2, 29, 2, 2, 7, 0, 5, 490, 0, 7, 5, 0, 1, 8, 0, 0, 23255, 0, 1}; |
||||
|
||||
// Test the example given on @see
|
||||
// http://guru.multimedia.cx/small-tasks-for-ffmpeg/
|
||||
int main(int argc, char **argv) |
||||
{ |
||||
int i, ret = 0; |
||||
// Probabilities of symbols 0..4
|
||||
static PTable val_counts[] = { |
||||
{.value = 0, .prob = 1}, |
||||
{.value = 1, .prob = 2}, |
||||
{.value = 2, .prob = 5}, |
||||
{.value = 3, .prob = 10}, |
||||
{.value = 4, .prob = 21}, |
||||
}; |
||||
// Expected code lengths for each symbol
|
||||
static const HuffTable expected[] = { |
||||
{.code = 0, .length = 3}, |
||||
{.code = 1, .length = 3}, |
||||
{.code = 2, .length = 3}, |
||||
{.code = 3, .length = 3}, |
||||
{.code = 4, .length = 1}, |
||||
}; |
||||
// Actual code lengths
|
||||
HuffTable distincts[5]; |
||||
|
||||
// Build optimal huffman tree using an internal function, to allow for
|
||||
// smaller-than-normal test cases. This mutates val_counts by sorting.
|
||||
ff_mjpegenc_huffman_compute_bits(val_counts, distincts, |
||||
FF_ARRAY_ELEMS(distincts), 3); |
||||
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(distincts); i++) { |
||||
if (distincts[i].code != expected[i].code || |
||||
distincts[i].length != expected[i].length) { |
||||
fprintf(stderr, |
||||
"Built huffman does not equal expectations. " |
||||
"Expected: code %d probability %d, " |
||||
"Actual: code %d probability %d\n", |
||||
expected[i].code, expected[i].length, |
||||
distincts[i].code, distincts[i].length); |
||||
ret = 1; |
||||
} |
||||
} |
||||
|
||||
// Check handling of zero probabilities
|
||||
if (check_lengths(16, 18, probs_zeroes, FF_ARRAY_ELEMS(probs_zeroes))) |
||||
ret = 1; |
||||
// Check skewed distribution over 256 without saturated lengths
|
||||
if (check_lengths(16, 41282, probs_skewed, FF_ARRAY_ELEMS(probs_skewed))) |
||||
ret = 1; |
||||
// Check skewed distribution over 256 with saturated lengths
|
||||
if (check_lengths(16, 669904, probs_sat, FF_ARRAY_ELEMS(probs_sat))) |
||||
ret = 1; |
||||
|
||||
return ret; |
||||
} |
||||
@ -0,0 +1,4 @@ |
||||
63ea9bd494e16bad8f3a0c8dbb3dc11e *tests/data/fate/vsynth1-mjpeg-huffman.avi |
||||
1391380 tests/data/fate/vsynth1-mjpeg-huffman.avi |
||||
9a3b8169c251d19044f7087a95458c55 *tests/data/fate/vsynth1-mjpeg-huffman.out.rawvideo |
||||
stddev: 7.87 PSNR: 30.21 MAXDIFF: 63 bytes: 7603200/ 7603200 |
||||
@ -0,0 +1,4 @@ |
||||
d9410fa80c07edbd2a2b44ceb06086ca *tests/data/fate/vsynth1-mjpeg-trell-huffman.avi |
||||
1360456 tests/data/fate/vsynth1-mjpeg-trell-huffman.avi |
||||
0266b223bdd7928426a951164bb4a366 *tests/data/fate/vsynth1-mjpeg-trell-huffman.out.rawvideo |
||||
stddev: 7.68 PSNR: 30.42 MAXDIFF: 62 bytes: 7603200/ 7603200 |
||||
@ -0,0 +1,4 @@ |
||||
9bf00cd3188b7395b798bb10df376243 *tests/data/fate/vsynth2-mjpeg-huffman.avi |
||||
792742 tests/data/fate/vsynth2-mjpeg-huffman.avi |
||||
2b8c59c59e33d6ca7c85d31c5eeab7be *tests/data/fate/vsynth2-mjpeg-huffman.out.rawvideo |
||||
stddev: 4.87 PSNR: 34.37 MAXDIFF: 55 bytes: 7603200/ 7603200 |
||||
@ -0,0 +1,4 @@ |
||||
a59d99d31d24875161504820d4266e4d *tests/data/fate/vsynth2-mjpeg-trell-huffman.avi |
||||
734728 tests/data/fate/vsynth2-mjpeg-trell-huffman.avi |
||||
42376126213c73c86b408882e24ba015 *tests/data/fate/vsynth2-mjpeg-trell-huffman.out.rawvideo |
||||
stddev: 5.03 PSNR: 34.09 MAXDIFF: 67 bytes: 7603200/ 7603200 |
||||
@ -0,0 +1,4 @@ |
||||
eec435352485fec167179a63405505be *tests/data/fate/vsynth3-mjpeg-huffman.avi |
||||
48156 tests/data/fate/vsynth3-mjpeg-huffman.avi |
||||
c4fe7a2669afbd96c640748693fc4e30 *tests/data/fate/vsynth3-mjpeg-huffman.out.rawvideo |
||||
stddev: 8.60 PSNR: 29.43 MAXDIFF: 58 bytes: 86700/ 86700 |
||||
@ -0,0 +1,4 @@ |
||||
484fa337b71c06a0206243814c4894b0 *tests/data/fate/vsynth3-mjpeg-trell-huffman.avi |
||||
47816 tests/data/fate/vsynth3-mjpeg-trell-huffman.avi |
||||
f0ccfe4584d193fd6d690a85a70db188 *tests/data/fate/vsynth3-mjpeg-trell-huffman.out.rawvideo |
||||
stddev: 8.27 PSNR: 29.78 MAXDIFF: 55 bytes: 86700/ 86700 |
||||
@ -0,0 +1,4 @@ |
||||
007c989af621445dc7c9bd248b9df3b4 *tests/data/fate/vsynth_lena-mjpeg-huffman.avi |
||||
635498 tests/data/fate/vsynth_lena-mjpeg-huffman.avi |
||||
9d4bd90e9abfa18192383b4adc23c8d4 *tests/data/fate/vsynth_lena-mjpeg-huffman.out.rawvideo |
||||
stddev: 4.32 PSNR: 35.40 MAXDIFF: 49 bytes: 7603200/ 7603200 |
||||
@ -0,0 +1,4 @@ |
||||
6eb36ab28a082f496f1f3bc165704a68 *tests/data/fate/vsynth_lena-mjpeg-trell-huffman.avi |
||||
582534 tests/data/fate/vsynth_lena-mjpeg-trell-huffman.avi |
||||
dcb183a6a5fa06e7234d46dd97ceb8ec *tests/data/fate/vsynth_lena-mjpeg-trell-huffman.out.rawvideo |
||||
stddev: 4.51 PSNR: 35.05 MAXDIFF: 60 bytes: 7603200/ 7603200 |
||||
Loading…
Reference in new issue