/*
* copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
*
- * This file is part of FFmpeg.
+ * This file is part of Libav.
*
- * FFmpeg is free software; you can redistribute it and/or
+ * Libav 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,
+ * Libav 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
+ * License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
- * @file libavcodec/put_bits.h
+ * @file
* bitstream writer API
*/
#include "libavutil/intreadwrite.h"
#include "libavutil/log.h"
#include "mathops.h"
+#include "config.h"
-//#define ALT_BITSTREAM_WRITER
-//#define ALIGNED_BITSTREAM_WRITER
-
-/* buf and buf_end must be present and used by every alternative writer. */
typedef struct PutBitContext {
-#ifdef ALT_BITSTREAM_WRITER
- uint8_t *buf, *buf_end;
- int index;
-#else
uint32_t bit_buf;
int bit_left;
uint8_t *buf, *buf_ptr, *buf_end;
-#endif
int size_in_bits;
} PutBitContext;
/**
- * Initializes the PutBitContext s.
+ * Initialize the PutBitContext s.
*
* @param buffer the buffer where to put bits
* @param buffer_size the size in bytes of buffer
s->size_in_bits= 8*buffer_size;
s->buf = buffer;
s->buf_end = s->buf + buffer_size;
-#ifdef ALT_BITSTREAM_WRITER
- s->index=0;
- ((uint32_t*)(s->buf))[0]=0;
-// memset(buffer, 0, buffer_size);
-#else
s->buf_ptr = s->buf;
s->bit_left=32;
s->bit_buf=0;
-#endif
}
/**
- * Returns the total number of bits written to the bitstream.
+ * @return the total number of bits written to the bitstream.
*/
static inline int put_bits_count(PutBitContext *s)
{
-#ifdef ALT_BITSTREAM_WRITER
- return s->index;
-#else
return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
-#endif
}
/**
- * Pads the end of the output stream with zeros.
+ * Pad the end of the output stream with zeros.
*/
static inline void flush_put_bits(PutBitContext *s)
{
-#ifdef ALT_BITSTREAM_WRITER
- align_put_bits(s);
-#else
#ifndef BITSTREAM_WRITER_LE
- s->bit_buf<<= s->bit_left;
+ if (s->bit_left < 32)
+ s->bit_buf<<= s->bit_left;
#endif
while (s->bit_left < 32) {
/* XXX: should test end of buffer */
}
s->bit_left=32;
s->bit_buf=0;
-#endif
}
+#ifdef BITSTREAM_WRITER_LE
+#define avpriv_align_put_bits align_put_bits_unsupported_here
+#define ff_put_string ff_put_string_unsupported_here
+#define avpriv_copy_bits avpriv_copy_bits_unsupported_here
+#else
/**
- * Pads the bitstream with zeros up to the next byte boundary.
+ * Pad the bitstream with zeros up to the next byte boundary.
*/
-void align_put_bits(PutBitContext *s);
+void avpriv_align_put_bits(PutBitContext *s);
/**
- * Puts the string string in the bitstream.
+ * Put the string string in the bitstream.
*
* @param terminate_string 0-terminates the written string if value is 1
*/
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string);
/**
- * Copies the content of src to the bitstream.
+ * Copy the content of src to the bitstream.
*
* @param length the number of bits of src to copy
*/
-void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
+void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
+#endif
/**
- * Writes up to 31 bits into a bitstream.
+ * Write up to 31 bits into a bitstream.
* Use put_bits32 to write 32 bits.
*/
static inline void put_bits(PutBitContext *s, int n, unsigned int value)
-#ifndef ALT_BITSTREAM_WRITER
{
unsigned int bit_buf;
int bit_left;
#ifdef BITSTREAM_WRITER_LE
bit_buf |= value << (32 - bit_left);
if (n >= bit_left) {
-#if !HAVE_FAST_UNALIGNED
- if (3 & (intptr_t) s->buf_ptr) {
- AV_WL32(s->buf_ptr, bit_buf);
- } else
-#endif
- *(uint32_t *)s->buf_ptr = le2me_32(bit_buf);
+ AV_WL32(s->buf_ptr, bit_buf);
s->buf_ptr+=4;
bit_buf = (bit_left==32)?0:value >> bit_left;
bit_left+=32;
} else {
bit_buf<<=bit_left;
bit_buf |= value >> (n - bit_left);
-#if !HAVE_FAST_UNALIGNED
- if (3 & (intptr_t) s->buf_ptr) {
- AV_WB32(s->buf_ptr, bit_buf);
- } else
-#endif
- *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
+ AV_WB32(s->buf_ptr, bit_buf);
//printf("bitbuf = %08x\n", bit_buf);
s->buf_ptr+=4;
bit_left+=32 - n;
s->bit_buf = bit_buf;
s->bit_left = bit_left;
}
-#else /* ALT_BITSTREAM_WRITER defined */
-{
-# ifdef ALIGNED_BITSTREAM_WRITER
-# if ARCH_X86
- __asm__ volatile(
- "movl %0, %%ecx \n\t"
- "xorl %%eax, %%eax \n\t"
- "shrdl %%cl, %1, %%eax \n\t"
- "shrl %%cl, %1 \n\t"
- "movl %0, %%ecx \n\t"
- "shrl $3, %%ecx \n\t"
- "andl $0xFFFFFFFC, %%ecx \n\t"
- "bswapl %1 \n\t"
- "orl %1, (%2, %%ecx) \n\t"
- "bswapl %%eax \n\t"
- "addl %3, %0 \n\t"
- "movl %%eax, 4(%2, %%ecx) \n\t"
- : "=&r" (s->index), "=&r" (value)
- : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
- : "%eax", "%ecx"
- );
-# else
- int index= s->index;
- uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
-
- value<<= 32-n;
-
- ptr[0] |= be2me_32(value>>(index&31));
- ptr[1] = be2me_32(value<<(32-(index&31)));
-//if(n>24) printf("%d %d\n", n, value);
- index+= n;
- s->index= index;
-# endif
-# else //ALIGNED_BITSTREAM_WRITER
-# if ARCH_X86
- __asm__ volatile(
- "movl $7, %%ecx \n\t"
- "andl %0, %%ecx \n\t"
- "addl %3, %%ecx \n\t"
- "negl %%ecx \n\t"
- "shll %%cl, %1 \n\t"
- "bswapl %1 \n\t"
- "movl %0, %%ecx \n\t"
- "shrl $3, %%ecx \n\t"
- "orl %1, (%%ecx, %2) \n\t"
- "addl %3, %0 \n\t"
- "movl $0, 4(%%ecx, %2) \n\t"
- : "=&r" (s->index), "=&r" (value)
- : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
- : "%ecx"
- );
-# else
- int index= s->index;
- uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
-
- ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
- ptr[1] = 0;
-//if(n>24) printf("%d %d\n", n, value);
- index+= n;
- s->index= index;
-# endif
-# endif //!ALIGNED_BITSTREAM_WRITER
-}
-#endif
static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
{
}
/**
- * Writes exactly 32 bits into a bitstream.
+ * Write exactly 32 bits into a bitstream.
*/
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
{
}
/**
- * Returns the pointer to the byte where the bitstream writer will put
+ * Return the pointer to the byte where the bitstream writer will put
* the next bit.
*/
static inline uint8_t* put_bits_ptr(PutBitContext *s)
{
-#ifdef ALT_BITSTREAM_WRITER
- return s->buf + (s->index>>3);
-#else
return s->buf_ptr;
-#endif
}
/**
- * Skips the given number of bytes.
+ * Skip the given number of bytes.
* PutBitContext must be flushed & aligned to a byte boundary before calling this.
*/
static inline void skip_put_bytes(PutBitContext *s, int n)
{
assert((put_bits_count(s)&7)==0);
-#ifdef ALT_BITSTREAM_WRITER
- FIXME may need some cleaning of the buffer
- s->index += n<<3;
-#else
assert(s->bit_left==32);
s->buf_ptr += n;
-#endif
}
/**
- * Skips the given number of bits.
+ * Skip the given number of bits.
* Must only be used if the actual values in the bitstream do not matter.
* If n is 0 the behavior is undefined.
*/
static inline void skip_put_bits(PutBitContext *s, int n)
{
-#ifdef ALT_BITSTREAM_WRITER
- s->index += n;
-#else
s->bit_left -= n;
s->buf_ptr-= 4*(s->bit_left>>5);
s->bit_left &= 31;
-#endif
}
/**
- * Changes the end of the buffer.
+ * Change the end of the buffer.
*
* @param size the new size in bytes of the buffer where to put bits
*/
projects / ffmpeg / blobdiff