1/* 2 * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> 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 8 * License 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 GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21#include "config.h" 22#include "bswap.h" 23#include "crc.h" 24 25#if CONFIG_HARDCODED_TABLES 26#include "crc_data.h" 27#else 28static struct { 29 uint8_t le; 30 uint8_t bits; 31 uint32_t poly; 32} av_crc_table_params[AV_CRC_MAX] = { 33 [AV_CRC_8_ATM] = { 0, 8, 0x07 }, 34 [AV_CRC_16_ANSI] = { 0, 16, 0x8005 }, 35 [AV_CRC_16_CCITT] = { 0, 16, 0x1021 }, 36 [AV_CRC_32_IEEE] = { 0, 32, 0x04C11DB7 }, 37 [AV_CRC_32_IEEE_LE] = { 1, 32, 0xEDB88320 }, 38}; 39static AVCRC av_crc_table[AV_CRC_MAX][257]; 40#endif 41 42/** 43 * Initializes a CRC table. 44 * @param ctx must be an array of size sizeof(AVCRC)*257 or sizeof(AVCRC)*1024 45 * @param cts_size size of ctx in bytes 46 * @param le If 1, the lowest bit represents the coefficient for the highest 47 * exponent of the corresponding polynomial (both for poly and 48 * actual CRC). 49 * If 0, you must swap the CRC parameter and the result of av_crc 50 * if you need the standard representation (can be simplified in 51 * most cases to e.g. bswap16): 52 * bswap_32(crc << (32-bits)) 53 * @param bits number of bits for the CRC 54 * @param poly generator polynomial without the x**bits coefficient, in the 55 * representation as specified by le 56 * @return <0 on failure 57 */ 58int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size){ 59 int i, j; 60 uint32_t c; 61 62 if (bits < 8 || bits > 32 || poly >= (1LL<<bits)) 63 return -1; 64 if (ctx_size != sizeof(AVCRC)*257 && ctx_size != sizeof(AVCRC)*1024) 65 return -1; 66 67 for (i = 0; i < 256; i++) { 68 if (le) { 69 for (c = i, j = 0; j < 8; j++) 70 c = (c>>1)^(poly & (-(c&1))); 71 ctx[i] = c; 72 } else { 73 for (c = i << 24, j = 0; j < 8; j++) 74 c = (c<<1) ^ ((poly<<(32-bits)) & (((int32_t)c)>>31) ); 75 ctx[i] = bswap_32(c); 76 } 77 } 78 ctx[256]=1; 79#if !CONFIG_SMALL 80 if(ctx_size >= sizeof(AVCRC)*1024) 81 for (i = 0; i < 256; i++) 82 for(j=0; j<3; j++) 83 ctx[256*(j+1) + i]= (ctx[256*j + i]>>8) ^ ctx[ ctx[256*j + i]&0xFF ]; 84#endif 85 86 return 0; 87} 88 89/** 90 * Gets an initialized standard CRC table. 91 * @param crc_id ID of a standard CRC 92 * @return a pointer to the CRC table or NULL on failure 93 */ 94const AVCRC *av_crc_get_table(AVCRCId crc_id){ 95#if !CONFIG_HARDCODED_TABLES 96 if (!av_crc_table[crc_id][FF_ARRAY_ELEMS(av_crc_table[crc_id])-1]) 97 if (av_crc_init(av_crc_table[crc_id], 98 av_crc_table_params[crc_id].le, 99 av_crc_table_params[crc_id].bits, 100 av_crc_table_params[crc_id].poly, 101 sizeof(av_crc_table[crc_id])) < 0) 102 return NULL; 103#endif 104 return av_crc_table[crc_id]; 105} 106 107/** 108 * Calculates the CRC of a block. 109 * @param crc CRC of previous blocks if any or initial value for CRC 110 * @return CRC updated with the data from the given block 111 * 112 * @see av_crc_init() "le" parameter 113 */ 114uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length){ 115 const uint8_t *end= buffer+length; 116 117#if !CONFIG_SMALL 118 if(!ctx[256]) 119 while(buffer<end-3){ 120 crc ^= le2me_32(*(const uint32_t*)buffer); buffer+=4; 121 crc = ctx[3*256 + ( crc &0xFF)] 122 ^ctx[2*256 + ((crc>>8 )&0xFF)] 123 ^ctx[1*256 + ((crc>>16)&0xFF)] 124 ^ctx[0*256 + ((crc>>24) )]; 125 } 126#endif 127 while(buffer<end) 128 crc = ctx[((uint8_t)crc) ^ *buffer++] ^ (crc >> 8); 129 130 return crc; 131} 132 133#ifdef TEST 134#undef printf 135int main(void){ 136 uint8_t buf[1999]; 137 int i; 138 int p[4][3]={{AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04}, 139 {AV_CRC_32_IEEE , 0x04C11DB7, 0xC0F5BAE0}, 140 {AV_CRC_16_ANSI , 0x8005, 0x1FBB }, 141 {AV_CRC_8_ATM , 0x07, 0xE3 },}; 142 const AVCRC *ctx; 143 144 for(i=0; i<sizeof(buf); i++) 145 buf[i]= i+i*i; 146 147 for(i=0; i<4; i++){ 148 ctx = av_crc_get_table(p[i][0]); 149 printf("crc %08X =%X\n", p[i][1], av_crc(ctx, 0, buf, sizeof(buf))); 150 } 151 return 0; 152} 153#endif 154