falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

Move av_reverse table to libavcodec 

It is only used in that library.
tags/n1.1
Diego Biurrun 12 years ago
parent
930c9d4373
commit
d5c62122a7
16 changed files with 90 additions and 49 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +4
    -3
      libavcodec/asvdec.c
  2. +4
    -3
      libavcodec/asvenc.c
  3. +5
    -4
      libavcodec/bitstream.c
  4. +4
    -2
      libavcodec/indeo2.c
  5. +4
    -3
      libavcodec/ivi_common.c
  6. +1
    -0
      libavcodec/mathops.h
  7. +19
    -0
      libavcodec/mathtables.c
  8. +6
    -5
      libavcodec/pcm.c
  9. +20
    -19
      libavcodec/s302m.c
  10. +4
    -3
      libavcodec/tiff.c
  11. +2
    -1
      libavcodec/vble.c
  12. +3
    -3
      libavcodec/wnv1.c
  13. +2
    -2
      libavcodec/xbmenc.c
  14. +5
    -1
      libavutil/common.h
  15. +4
    -0
      libavutil/mathematics.c
  16. +3
    -0
      libavutil/version.h

+ 4
- 3
libavcodec/asvdec.c View File

@@ -23,13 +23,14 @@
* ASUS V1/V2 decoder.
*/

#include "libavutil/common.h"
#include "libavutil/attributes.h"
#include "libavutil/mem.h"

#include "asv.h"
#include "avcodec.h"
#include "put_bits.h"
#include "dsputil.h"
#include "mathops.h"
#include "mpeg12data.h"

//#undef NDEBUG
@@ -70,7 +71,7 @@ static av_cold void init_vlcs(ASV1Context *a){

//FIXME write a reversed bitstream reader to avoid the double reverse
static inline int asv2_get_bits(GetBitContext *gb, int n){
return av_reverse[ get_bits(gb, n) << (8-n) ];
return ff_reverse[ get_bits(gb, n) << (8-n) ];
}

static inline int asv1_get_level(GetBitContext *gb){
@@ -210,7 +211,7 @@ static int decode_frame(AVCodecContext *avctx,
else{
int i;
for(i=0; i<buf_size; i++)
a->bitstream_buffer[i]= av_reverse[ buf[i] ];
a->bitstream_buffer[i]= ff_reverse[ buf[i] ];
}

init_get_bits(&a->gb, a->bitstream_buffer, buf_size*8);


+ 4
- 3
libavcodec/asvenc.c View File

@@ -23,15 +23,16 @@
* ASUS V1/V2 encoder.
*/

#include "libavutil/common.h"
#include "libavutil/attributes.h"
#include "libavutil/mem.h"

#include "asv.h"
#include "avcodec.h"
#include "mathops.h"
#include "mpeg12data.h"

static inline void asv2_put_bits(PutBitContext *pb, int n, int v){
put_bits(pb, n, av_reverse[ v << (8-n) ]);
put_bits(pb, n, ff_reverse[ v << (8-n) ]);
}

static inline void asv1_put_level(PutBitContext *pb, int level){
@@ -226,7 +227,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
else{
int i;
for(i=0; i<4*size; i++)
pkt->data[i] = av_reverse[pkt->data[i]];
pkt->data[i] = ff_reverse[pkt->data[i]];
}

pkt->size = size*4;


+ 5
- 4
libavcodec/bitstream.c View File

@@ -29,6 +29,7 @@
*/

#include "avcodec.h"
#include "mathops.h"
#include "get_bits.h"
#include "put_bits.h"

@@ -114,10 +115,10 @@ static int alloc_table(VLC *vlc, int size, int use_static)
}

static av_always_inline uint32_t bitswap_32(uint32_t x) {
return (uint32_t)av_reverse[x&0xFF]<<24
| (uint32_t)av_reverse[(x>>8)&0xFF]<<16
| (uint32_t)av_reverse[(x>>16)&0xFF]<<8
| (uint32_t)av_reverse[x>>24];
return (uint32_t)ff_reverse[x&0xFF]<<24
| (uint32_t)ff_reverse[(x>>8)&0xFF]<<16
| (uint32_t)ff_reverse[(x>>16)&0xFF]<<8
| (uint32_t)ff_reverse[x>>24];
}

typedef struct {


+ 4
- 2
libavcodec/indeo2.c View File

@@ -23,11 +23,13 @@
* @file
* Intel Indeo 2 decoder.
*/

#define BITSTREAM_READER_LE
#include "libavutil/attributes.h"
#include "avcodec.h"
#include "get_bits.h"
#include "indeo2data.h"
#include "libavutil/common.h"
#include "mathops.h"

typedef struct Ir2Context{
AVCodecContext *avctx;
@@ -168,7 +170,7 @@ static int ir2_decode_frame(AVCodecContext *avctx,
/* decide whether frame uses deltas or not */
#ifndef BITSTREAM_READER_LE
for (i = 0; i < buf_size; i++)
buf[i] = av_reverse[buf[i]];
buf[i] = ff_reverse[buf[i]];
#endif

init_get_bits(&s->gb, buf + start, (buf_size - start) * 8);


+ 4
- 3
libavcodec/ivi_common.c View File

@@ -27,10 +27,11 @@
*/

#define BITSTREAM_READER_LE
#include "libavutil/attributes.h"
#include "avcodec.h"
#include "get_bits.h"
#include "mathops.h"
#include "ivi_common.h"
#include "libavutil/common.h"
#include "ivi_dsp.h"

extern const IVIHuffDesc ff_ivi_mb_huff_desc[8]; ///< static macroblock huffman tables
@@ -48,9 +49,9 @@ static uint16_t inv_bits(uint16_t val, int nbits)
uint16_t res;

if (nbits <= 8) {
res = av_reverse[val] >> (8-nbits);
res = ff_reverse[val] >> (8-nbits);
} else
res = ((av_reverse[val & 0xFF] << 8) + (av_reverse[val >> 8])) >> (16-nbits);
res = ((ff_reverse[val & 0xFF] << 8) + (ff_reverse[val >> 8])) >> (16-nbits);

return res;
}


+ 1
- 0
libavcodec/mathops.h View File

@@ -28,6 +28,7 @@
#include "config.h"

extern const uint32_t ff_inverse[257];
extern const uint8_t ff_reverse[256];
extern const uint8_t ff_sqrt_tab[256];

#if ARCH_ARM


+ 19
- 0
libavcodec/mathtables.c View File

@@ -66,3 +66,22 @@ const uint8_t ff_sqrt_tab[256]={
222,223,223,224,224,225,226,226,227,227,228,228,229,230,230,231,231,232,232,233,233,234,235,235,236,236,237,237,238,238,239,239,
240,240,241,242,242,243,243,244,244,245,245,246,246,247,247,248,248,249,249,250,250,251,251,252,252,253,253,254,254,255,255,255
};

const uint8_t ff_reverse[256] = {
0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
};

+ 6
- 5
libavcodec/pcm.c View File

@@ -24,10 +24,11 @@
* PCM codecs
*/

#include "libavutil/common.h" /* for av_reverse */
#include "libavutil/attributes.h"
#include "avcodec.h"
#include "bytestream.h"
#include "internal.h"
#include "mathops.h"
#include "pcm_tablegen.h"

#define MAX_CHANNELS 64
@@ -124,8 +125,8 @@ static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
break;
case AV_CODEC_ID_PCM_S24DAUD:
for (; n > 0; n--) {
uint32_t tmp = av_reverse[(*samples >> 8) & 0xff] +
(av_reverse[*samples & 0xff] << 8);
uint32_t tmp = ff_reverse[(*samples >> 8) & 0xff] +
(ff_reverse[*samples & 0xff] << 8);
tmp <<= 4; // sync flags would go here
bytestream_put_be24(&dst, tmp);
samples++;
@@ -332,8 +333,8 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
for (; n > 0; n--) {
uint32_t v = bytestream_get_be24(&src);
v >>= 4; // sync flags are here
AV_WN16A(samples, av_reverse[(v >> 8) & 0xff] +
(av_reverse[v & 0xff] << 8));
AV_WN16A(samples, ff_reverse[(v >> 8) & 0xff] +
(ff_reverse[v & 0xff] << 8));
samples += 2;
}
break;


+ 20
- 19
libavcodec/s302m.c View File

@@ -20,9 +20,10 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/log.h"
#include "avcodec.h"
#include "mathops.h"

#define AES3_HEADER_LEN 4

@@ -105,34 +106,34 @@ static int s302m_decode_frame(AVCodecContext *avctx, void *data,
if (avctx->bits_per_coded_sample == 24) {
uint32_t *o = (uint32_t *)s->frame.data[0];
for (; buf_size > 6; buf_size -= 7) {
*o++ = (av_reverse[buf[2]] << 24) |
(av_reverse[buf[1]] << 16) |
(av_reverse[buf[0]] << 8);
*o++ = (av_reverse[buf[6] & 0xf0] << 28) |
(av_reverse[buf[5]] << 20) |
(av_reverse[buf[4]] << 12) |
(av_reverse[buf[3] & 0x0f] << 4);
*o++ = (ff_reverse[buf[2]] << 24) |
(ff_reverse[buf[1]] << 16) |
(ff_reverse[buf[0]] << 8);
*o++ = (ff_reverse[buf[6] & 0xf0] << 28) |
(ff_reverse[buf[5]] << 20) |
(ff_reverse[buf[4]] << 12) |
(ff_reverse[buf[3] & 0x0f] << 4);
buf += 7;
}
} else if (avctx->bits_per_coded_sample == 20) {
uint32_t *o = (uint32_t *)s->frame.data[0];
for (; buf_size > 5; buf_size -= 6) {
*o++ = (av_reverse[buf[2] & 0xf0] << 28) |
(av_reverse[buf[1]] << 20) |
(av_reverse[buf[0]] << 12);
*o++ = (av_reverse[buf[5] & 0xf0] << 28) |
(av_reverse[buf[4]] << 20) |
(av_reverse[buf[3]] << 12);
*o++ = (ff_reverse[buf[2] & 0xf0] << 28) |
(ff_reverse[buf[1]] << 20) |
(ff_reverse[buf[0]] << 12);
*o++ = (ff_reverse[buf[5] & 0xf0] << 28) |
(ff_reverse[buf[4]] << 20) |
(ff_reverse[buf[3]] << 12);
buf += 6;
}
} else {
uint16_t *o = (uint16_t *)s->frame.data[0];
for (; buf_size > 4; buf_size -= 5) {
*o++ = (av_reverse[buf[1]] << 8) |
av_reverse[buf[0]];
*o++ = (av_reverse[buf[4] & 0xf0] << 12) |
(av_reverse[buf[3]] << 4) |
(av_reverse[buf[2]] >> 4);
*o++ = (ff_reverse[buf[1]] << 8) |
ff_reverse[buf[0]];
*o++ = (ff_reverse[buf[4] & 0xf0] << 12) |
(ff_reverse[buf[3]] << 4) |
(ff_reverse[buf[2]] >> 4);
buf += 5;
}
}


+ 4
- 3
libavcodec/tiff.c View File

@@ -33,7 +33,8 @@
#include "lzw.h"
#include "tiff.h"
#include "faxcompr.h"
#include "libavutil/common.h"
#include "mathops.h"
#include "libavutil/attributes.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/imgutils.h"

@@ -171,7 +172,7 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
memcpy(src2, src, size);
} else {
for (i = 0; i < size; i++)
src2[i] = av_reverse[src[i]];
src2[i] = ff_reverse[src[i]];
}
memset(src2 + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
switch (s->compr) {
@@ -199,7 +200,7 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
} else {
int i;
for (i = 0; i < width; i++)
dst[i] = av_reverse[src[i]];
dst[i] = ff_reverse[src[i]];
}
src += width;
break;


+ 2
- 1
libavcodec/vble.c View File

@@ -29,6 +29,7 @@
#include "avcodec.h"
#include "dsputil.h"
#include "get_bits.h"
#include "mathops.h"

typedef struct {
AVCodecContext *avctx;
@@ -44,7 +45,7 @@ static uint8_t vble_read_reverse_unary(GetBitContext *gb)
uint8_t val = show_bits(gb, 8);

if (val) {
val = 7 - av_log2_16bit(av_reverse[val]);
val = 7 - av_log2_16bit(ff_reverse[val]);
skip_bits(gb, val + 1);
return val;
} else {


+ 3
- 3
libavcodec/wnv1.c View File

@@ -26,7 +26,7 @@

#include "avcodec.h"
#include "get_bits.h"
#include "libavutil/common.h"
#include "mathops.h"


typedef struct WNV1Context{
@@ -52,7 +52,7 @@ static inline int wnv1_get_code(WNV1Context *w, int base_value)
int v = get_vlc2(&w->gb, code_vlc.table, CODE_VLC_BITS, 1);

if(v==15)
return av_reverse[ get_bits(&w->gb, 8 - w->shift) ];
return ff_reverse[ get_bits(&w->gb, 8 - w->shift) ];
else
return base_value + ((v - 7)<<w->shift);
}
@@ -88,7 +88,7 @@ static int decode_frame(AVCodecContext *avctx,
p->key_frame = 1;

for(i=8; i<buf_size; i++)
rbuf[i]= av_reverse[ buf[i] ];
rbuf[i]= ff_reverse[ buf[i] ];
init_get_bits(&l->gb, rbuf+8, (buf_size-8)*8);

if (buf[2] >> 4 == 6)


+ 2
- 2
libavcodec/xbmenc.c View File

@@ -22,7 +22,7 @@

#include "avcodec.h"
#include "internal.h"
#include "libavutil/common.h"
#include "mathops.h"

static av_cold int xbm_encode_init(AVCodecContext *avctx)
{
@@ -55,7 +55,7 @@ static int xbm_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
buf += snprintf(buf, 40, "static unsigned char image_bits[] = {\n");
for (i = 0; i < avctx->height; i++) {
for (j = 0; j < linesize; j++)
buf += snprintf(buf, 7, " 0x%02X,", av_reverse[*ptr++]);
buf += snprintf(buf, 7, " 0x%02X,", ff_reverse[*ptr++]);
ptr += p->linesize[0] - linesize;
buf += snprintf(buf, 2, "\n");
}


+ 5
- 1
libavutil/common.h View File

@@ -34,7 +34,9 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "attributes.h"
#include "version.h"
#include "libavutil/avconfig.h"

#if AV_HAVE_BIGENDIAN
@@ -62,7 +64,9 @@
/* misc math functions */
extern const uint8_t ff_log2_tab[256];

extern const uint8_t av_reverse[256];
#if FF_API_AV_REVERSE
extern attribute_deprecated const uint8_t av_reverse[256];
#endif

static av_always_inline av_const int av_log2_c(unsigned int v)
{


+ 4
- 0
libavutil/mathematics.c View File

@@ -26,8 +26,11 @@
#include <assert.h>
#include <stdint.h>
#include <limits.h>

#include "mathematics.h"
#include "version.h"

#if FF_API_AV_REVERSE
const uint8_t av_reverse[256]={
0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
@@ -46,6 +49,7 @@ const uint8_t av_reverse[256]={
0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
};
#endif

int64_t av_gcd(int64_t a, int64_t b){
if(b) return av_gcd(b, a%b);


+ 3
- 0
libavutil/version.h View File

@@ -82,6 +82,9 @@
#ifndef FF_API_PIX_FMT_DESC
#define FF_API_PIX_FMT_DESC (LIBAVUTIL_VERSION_MAJOR < 52)
#endif
#ifndef FF_API_AV_REVERSE
#define FF_API_AV_REVERSE (LIBAVUTIL_VERSION_MAJOR < 52)
#endif

/**
* @}


Write Preview
Loading…
Cancel
Save