Originally committed as revision 9169 to svn://svn.ffmpeg.org/ffmpeg/trunktags/v0.5
| @@ -1136,12 +1136,10 @@ static int output_frame_end(AC3EncodeContext *s) | |||
| /* XXX: could precompute crc_inv */ | |||
| crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58) - 16, CRC16_POLY); | |||
| crc1 = mul_poly(crc_inv, crc1, CRC16_POLY); | |||
| frame[2] = crc1 >> 8; | |||
| frame[3] = crc1; | |||
| AV_WB16(frame+2,crc1); | |||
| crc2 = bswap_16(av_crc(av_crc8005, 0, frame + 2 * frame_size_58, (frame_size - frame_size_58) * 2 - 2)); | |||
| frame[2*frame_size - 2] = crc2 >> 8; | |||
| frame[2*frame_size - 1] = crc2; | |||
| AV_WB16(frame+2*frame_size-2,crc2); | |||
| // printf("n=%d frame_size=%d\n", n, frame_size); | |||
| return frame_size * 2; | |||
| @@ -451,16 +451,14 @@ static int adpcm_encode_frame(AVCodecContext *avctx, | |||
| n = avctx->frame_size / 8; | |||
| c->status[0].prev_sample = (signed short)samples[0]; /* XXX */ | |||
| /* c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */ | |||
| *dst++ = (c->status[0].prev_sample) & 0xFF; /* little endian */ | |||
| *dst++ = (c->status[0].prev_sample >> 8) & 0xFF; | |||
| bytestream_put_le16(&dst, c->status[0].prev_sample); | |||
| *dst++ = (unsigned char)c->status[0].step_index; | |||
| *dst++ = 0; /* unknown */ | |||
| samples++; | |||
| if (avctx->channels == 2) { | |||
| c->status[1].prev_sample = (signed short)samples[1]; | |||
| /* c->status[1].step_index = 0; */ | |||
| *dst++ = (c->status[1].prev_sample) & 0xFF; | |||
| *dst++ = (c->status[1].prev_sample >> 8) & 0xFF; | |||
| bytestream_put_le16(&dst, c->status[1].prev_sample); | |||
| *dst++ = (unsigned char)c->status[1].step_index; | |||
| *dst++ = 0; | |||
| samples++; | |||
| @@ -553,20 +551,17 @@ static int adpcm_encode_frame(AVCodecContext *avctx, | |||
| if (c->status[i].idelta < 16) | |||
| c->status[i].idelta = 16; | |||
| *dst++ = c->status[i].idelta & 0xFF; | |||
| *dst++ = c->status[i].idelta >> 8; | |||
| bytestream_put_le16(&dst, c->status[i].idelta); | |||
| } | |||
| for(i=0; i<avctx->channels; i++){ | |||
| c->status[i].sample1= *samples++; | |||
| *dst++ = c->status[i].sample1 & 0xFF; | |||
| *dst++ = c->status[i].sample1 >> 8; | |||
| bytestream_put_le16(&dst, c->status[i].sample1); | |||
| } | |||
| for(i=0; i<avctx->channels; i++){ | |||
| c->status[i].sample2= *samples++; | |||
| *dst++ = c->status[i].sample2 & 0xFF; | |||
| *dst++ = c->status[i].sample2 >> 8; | |||
| bytestream_put_le16(&dst, c->status[i].sample2); | |||
| } | |||
| if(avctx->trellis > 0) { | |||
| @@ -25,6 +25,7 @@ | |||
| */ | |||
| #include "avcodec.h" | |||
| #include "bytestream.h" | |||
| typedef enum CinVideoBitmapIndex { | |||
| @@ -206,7 +207,7 @@ static int cinvideo_decode_frame(AVCodecContext *avctx, | |||
| } | |||
| palette_type = buf[0]; | |||
| palette_colors_count = buf[1] | (buf[2] << 8); | |||
| palette_colors_count = AV_RL16(buf+1); | |||
| bitmap_frame_type = buf[3]; | |||
| buf += 4; | |||
| @@ -215,13 +216,12 @@ static int cinvideo_decode_frame(AVCodecContext *avctx, | |||
| /* handle palette */ | |||
| if (palette_type == 0) { | |||
| for (i = 0; i < palette_colors_count; ++i) { | |||
| cin->palette[i] = (buf[2] << 16) | (buf[1] << 8) | buf[0]; | |||
| buf += 3; | |||
| cin->palette[i] = bytestream_get_le24(&buf); | |||
| bitmap_frame_size -= 3; | |||
| } | |||
| } else { | |||
| for (i = 0; i < palette_colors_count; ++i) { | |||
| cin->palette[buf[0]] = (buf[3] << 16) | (buf[2] << 8) | buf[1]; | |||
| cin->palette[buf[0]] = AV_RL24(buf+1); | |||
| buf += 4; | |||
| bitmap_frame_size -= 4; | |||
| } | |||
| @@ -132,13 +132,9 @@ static void gif_put_bits_rev(PutBitContext *s, int n, unsigned int value) | |||
| } else { | |||
| bit_buf |= value << (bit_cnt); | |||
| *s->buf_ptr = bit_buf & 0xff; | |||
| s->buf_ptr[1] = (bit_buf >> 8) & 0xff; | |||
| s->buf_ptr[2] = (bit_buf >> 16) & 0xff; | |||
| s->buf_ptr[3] = (bit_buf >> 24) & 0xff; | |||
| bytestream_put_le32(&s->buf_ptr, bit_buf); | |||
| //printf("bitbuf = %08x\n", bit_buf); | |||
| s->buf_ptr+=4; | |||
| if (s->buf_ptr >= s->buf_end) | |||
| puts("bit buffer overflow !!"); // should never happen ! who got rid of the callback ??? | |||
| // flush_buffer_rev(s); | |||
| @@ -195,9 +191,7 @@ static int gif_image_write_header(uint8_t **bytestream, | |||
| } else { | |||
| for(i=0;i<256;i++) { | |||
| v = palette[i]; | |||
| bytestream_put_byte(bytestream, (v >> 16) & 0xff); | |||
| bytestream_put_byte(bytestream, (v >> 8) & 0xff); | |||
| bytestream_put_byte(bytestream, (v) & 0xff); | |||
| bytestream_put_be24(bytestream, v); | |||
| } | |||
| } | |||
| @@ -96,8 +96,7 @@ static int gif_read_image(GifState *s) | |||
| n = (1 << bits_per_pixel); | |||
| spal = palette; | |||
| for(i = 0; i < n; i++) { | |||
| s->image_palette[i] = (0xff << 24) | | |||
| (spal[0] << 16) | (spal[1] << 8) | (spal[2]); | |||
| s->image_palette[i] = (0xff << 24) | AV_RB24(spal); | |||
| spal += 3; | |||
| } | |||
| for(; i < 256; i++) | |||
| @@ -41,6 +41,7 @@ | |||
| #include <unistd.h> | |||
| #include "avcodec.h" | |||
| #include "bytestream.h" | |||
| #include "dsputil.h" | |||
| #define PALETTE_COUNT 256 | |||
| @@ -297,10 +298,8 @@ static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s) | |||
| /* need 2 more bytes from the stream */ | |||
| CHECK_STREAM_PTR(2); | |||
| B[0] = *s->stream_ptr++; | |||
| B[1] = *s->stream_ptr++; | |||
| flags = (B[1] << 8) | B[0]; | |||
| flags = bytestream_get_le16(&s->stream_ptr); | |||
| bitmask = 0x0001; | |||
| for (y = 0; y < 8; y += 2) { | |||
| for (x = 0; x < 8; x += 2, bitmask <<= 1) { | |||
| @@ -478,7 +477,6 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s) | |||
| { | |||
| int x, y; | |||
| unsigned char P[4]; | |||
| unsigned char B[4]; | |||
| unsigned int flags = 0; | |||
| int shifter = 0; | |||
| unsigned char pix; | |||
| @@ -496,8 +494,7 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s) | |||
| for (y = 0; y < 8; y++) { | |||
| /* get the next set of 8 2-bit flags */ | |||
| flags = (s->stream_ptr[1] << 8) | s->stream_ptr[0]; | |||
| s->stream_ptr += 2; | |||
| flags = bytestream_get_le16(&s->stream_ptr); | |||
| for (x = 0, shifter = 0; x < 8; x++, shifter += 2) { | |||
| *s->pixel_ptr++ = P[(flags >> shifter) & 0x03]; | |||
| } | |||
| @@ -509,11 +506,7 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s) | |||
| /* 1 of 4 colors for each 2x2 block, need 4 more bytes */ | |||
| CHECK_STREAM_PTR(4); | |||
| B[0] = *s->stream_ptr++; | |||
| B[1] = *s->stream_ptr++; | |||
| B[2] = *s->stream_ptr++; | |||
| B[3] = *s->stream_ptr++; | |||
| flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; | |||
| flags = bytestream_get_le32(&s->stream_ptr); | |||
| shifter = 0; | |||
| for (y = 0; y < 8; y += 2) { | |||
| @@ -535,11 +528,7 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s) | |||
| for (y = 0; y < 8; y++) { | |||
| /* time to reload flags? */ | |||
| if ((y == 0) || (y == 4)) { | |||
| B[0] = *s->stream_ptr++; | |||
| B[1] = *s->stream_ptr++; | |||
| B[2] = *s->stream_ptr++; | |||
| B[3] = *s->stream_ptr++; | |||
| flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; | |||
| flags = bytestream_get_le32(&s->stream_ptr); | |||
| shifter = 0; | |||
| } | |||
| for (x = 0; x < 8; x += 2, shifter += 2) { | |||
| @@ -558,11 +547,7 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s) | |||
| for (y = 0; y < 8; y += 2) { | |||
| /* time to reload flags? */ | |||
| if ((y == 0) || (y == 4)) { | |||
| B[0] = *s->stream_ptr++; | |||
| B[1] = *s->stream_ptr++; | |||
| B[2] = *s->stream_ptr++; | |||
| B[3] = *s->stream_ptr++; | |||
| flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; | |||
| flags = bytestream_get_le32(&s->stream_ptr); | |||
| shifter = 0; | |||
| } | |||
| for (x = 0; x < 8; x++, shifter += 2) { | |||
| @@ -29,6 +29,7 @@ | |||
| #include <stdlib.h> | |||
| #include "avcodec.h" | |||
| #include "bytestream.h" | |||
| #define KMVC_KEYFRAME 0x80 | |||
| #define KMVC_PALETTE 0x40 | |||
| @@ -249,7 +250,7 @@ static int decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint | |||
| if (buf[0] == 127) { | |||
| buf += 3; | |||
| for (i = 0; i < 127; i++) { | |||
| ctx->pal[i + (header & 0x81)] = (buf[0] << 16) | (buf[1] << 8) | buf[2]; | |||
| ctx->pal[i + (header & 0x81)] = AV_RB24(buf); | |||
| buf += 4; | |||
| } | |||
| buf -= 127 * 4 + 3; | |||
| @@ -274,8 +275,7 @@ static int decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint | |||
| ctx->pic.palette_has_changed = 1; | |||
| // palette starts from index 1 and has 127 entries | |||
| for (i = 1; i <= ctx->palsize; i++) { | |||
| ctx->pal[i] = (buf[0] << 16) | (buf[1] << 8) | buf[2]; | |||
| buf += 3; | |||
| ctx->pal[i] = bytestream_get_be24(&buf); | |||
| } | |||
| } | |||
| @@ -358,13 +358,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8 | |||
| for (row = 0; row < height; row++) { | |||
| pixel_ptr = row * width * 3; | |||
| yq = encoded[pixel_ptr++]; | |||
| uqvq = encoded[pixel_ptr++]; | |||
| uqvq+=(encoded[pixel_ptr++] << 8); | |||
| uqvq = AV_RL16(encoded+pixel_ptr); | |||
| pixel_ptr += 2; | |||
| for (col = 1; col < width; col++) { | |||
| encoded[pixel_ptr] = yq -= encoded[pixel_ptr]; | |||
| uqvq -= (encoded[pixel_ptr+1] | (encoded[pixel_ptr+2]<<8)); | |||
| encoded[pixel_ptr+1] = (uqvq) & 0xff; | |||
| encoded[pixel_ptr+2] = ((uqvq)>>8) & 0xff; | |||
| uqvq -= AV_RL16(encoded+pixel_ptr+1); | |||
| AV_WL16(encoded+pixel_ptr+1, uqvq); | |||
| pixel_ptr += 3; | |||
| } | |||
| } | |||
| @@ -69,8 +69,8 @@ static int concatenate_packet(unsigned int* offset, AVCodecContext* avc_context, | |||
| avc_context->extradata = newdata; | |||
| avc_context->extradata_size = newsize; | |||
| avc_context->extradata[ (*offset)++ ] = packet->bytes >> 8; | |||
| avc_context->extradata[ (*offset)++ ] = packet->bytes & 0xff; | |||
| AV_WB16(avc_context->extradata + (*offset), packet->bytes); | |||
| *offset += 2; | |||
| memcpy( avc_context->extradata + (*offset), packet->packet, packet->bytes ); | |||
| (*offset) += packet->bytes; | |||
| return 0; | |||
| @@ -147,8 +147,7 @@ static void jpeg_table_header(MpegEncContext *s) | |||
| ff_mjpeg_val_ac_luminance); | |||
| size += put_huffman_table(s, 1, 1, ff_mjpeg_bits_ac_chrominance, | |||
| ff_mjpeg_val_ac_chrominance); | |||
| ptr[0] = size >> 8; | |||
| ptr[1] = size; | |||
| AV_WB16(ptr, size); | |||
| } | |||
| static void jpeg_put_comments(MpegEncContext *s) | |||
| @@ -179,8 +178,7 @@ static void jpeg_put_comments(MpegEncContext *s) | |||
| put_bits(p, 16, 0); /* patched later */ | |||
| ff_put_string(p, LIBAVCODEC_IDENT, 1); | |||
| size = strlen(LIBAVCODEC_IDENT)+3; | |||
| ptr[0] = size >> 8; | |||
| ptr[1] = size; | |||
| AV_WB16(ptr, size); | |||
| } | |||
| if( s->avctx->pix_fmt == PIX_FMT_YUV420P | |||
| @@ -192,8 +190,7 @@ static void jpeg_put_comments(MpegEncContext *s) | |||
| put_bits(p, 16, 0); /* patched later */ | |||
| ff_put_string(p, "CS=ITU601", 1); | |||
| size = strlen("CS=ITU601")+3; | |||
| ptr[0] = size >> 8; | |||
| ptr[1] = size; | |||
| AV_WB16(ptr, size); | |||
| } | |||
| } | |||
| @@ -84,10 +84,7 @@ static int mp3_header_decompress(AVBitStreamFilterContext *bsfc, AVCodecContext | |||
| } | |||
| } | |||
| (*poutbuf)[0]= header>>24; | |||
| (*poutbuf)[1]= header>>16; | |||
| (*poutbuf)[2]= header>> 8; | |||
| (*poutbuf)[3]= header ; | |||
| AV_WB32(*poutbuf, header); | |||
| return 1; | |||
| } | |||
| @@ -106,8 +106,7 @@ static const int sBitsPerSlot[3] = { | |||
| static int mp3len(void *data, int *samplesPerFrame, int *sampleRate) | |||
| { | |||
| uint8_t *dataTmp = (uint8_t *)data; | |||
| uint32_t header = ( (uint32_t)dataTmp[0] << 24 ) | ( (uint32_t)dataTmp[1] << 16 ) | ( (uint32_t)dataTmp[2] << 8 ) | (uint32_t)dataTmp[3]; | |||
| uint32_t header = AV_RB32(data); | |||
| int layerID = 3 - ((header >> 17) & 0x03); | |||
| int bitRateID = ((header >> 12) & 0x0f); | |||
| int sampleRateID = ((header >> 10) & 0x03); | |||
| @@ -105,10 +105,7 @@ static int mpegaudio_parse(AVCodecParserContext *s1, | |||
| /* special case for next header for first frame in free | |||
| format case (XXX: find a simpler method) */ | |||
| if (s->free_format_next_header != 0) { | |||
| s->inbuf[0] = s->free_format_next_header >> 24; | |||
| s->inbuf[1] = s->free_format_next_header >> 16; | |||
| s->inbuf[2] = s->free_format_next_header >> 8; | |||
| s->inbuf[3] = s->free_format_next_header; | |||
| AV_WB32(s->inbuf, s->free_format_next_header); | |||
| s->inbuf_ptr = s->inbuf + 4; | |||
| s->free_format_next_header = 0; | |||
| goto got_header; | |||
| @@ -124,8 +121,7 @@ static int mpegaudio_parse(AVCodecParserContext *s1, | |||
| } | |||
| if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) { | |||
| got_header: | |||
| header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) | | |||
| (s->inbuf[2] << 8) | s->inbuf[3]; | |||
| header = AV_RB32(s->inbuf); | |||
| ret = ff_mpa_decode_header(avctx, header, &sr); | |||
| if (ret < 0) { | |||
| @@ -176,10 +172,8 @@ static int mpegaudio_parse(AVCodecParserContext *s1, | |||
| p = s->inbuf_ptr - 3; | |||
| pend = s->inbuf_ptr + len - 4; | |||
| while (p <= pend) { | |||
| header = (p[0] << 24) | (p[1] << 16) | | |||
| (p[2] << 8) | p[3]; | |||
| header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) | | |||
| (s->inbuf[2] << 8) | s->inbuf[3]; | |||
| header = AV_RB32(p); | |||
| header1 = AV_RB32(s->inbuf); | |||
| /* check with high probability that we have a | |||
| valid header */ | |||
| if ((header & SAME_HEADER_MASK) == | |||
| @@ -2380,7 +2380,7 @@ retry: | |||
| if(buf_size < HEADER_SIZE) | |||
| return -1; | |||
| header = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]; | |||
| header = AV_RB32(buf); | |||
| if(ff_mpa_check_header(header) < 0){ | |||
| buf++; | |||
| // buf_size--; | |||
| @@ -2459,7 +2459,7 @@ static int decode_frame_adu(AVCodecContext * avctx, | |||
| len = MPA_MAX_CODED_FRAME_SIZE; | |||
| // Get header and restore sync word | |||
| header = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3] | 0xffe00000; | |||
| header = AV_RB32(buf) | 0xffe00000; | |||
| if (ff_mpa_check_header(header) < 0) { // Bad header, discard frame | |||
| *data_size = 0; | |||
| @@ -2604,7 +2604,7 @@ static int decode_frame_mp3on4(AVCodecContext * avctx, | |||
| assert (m != NULL); | |||
| // Get header | |||
| header = (start[0] << 24) | (start[1] << 16) | (start[2] << 8) | start[3] | 0xfff00000; | |||
| header = AV_RB32(start) | 0xfff00000; | |||
| if (ff_mpa_check_header(header) < 0) { // Bad header, discard block | |||
| *data_size = 0; | |||
| @@ -27,6 +27,7 @@ | |||
| #include <vorbis/vorbisenc.h> | |||
| #include "avcodec.h" | |||
| #include "bytestream.h" | |||
| #undef NDEBUG | |||
| #include <assert.h> | |||
| @@ -234,8 +235,7 @@ static int oggvorbis_decode_init(AVCodecContext *avccontext) { | |||
| if(p[0] == 0 && p[1] == 30) { | |||
| for(i = 0; i < 3; i++){ | |||
| hsizes[i] = *p++ << 8; | |||
| hsizes[i] += *p++; | |||
| hsizes[i] = bytestream_get_be16(&p); | |||
| headers[i] = p; | |||
| p += hsizes[i]; | |||
| } | |||
| @@ -693,10 +693,7 @@ static void png_write_chunk(uint8_t **f, uint32_t tag, | |||
| bytestream_put_be32(f, length); | |||
| crc = crc32(0, Z_NULL, 0); | |||
| tagbuf[0] = tag; | |||
| tagbuf[1] = tag >> 8; | |||
| tagbuf[2] = tag >> 16; | |||
| tagbuf[3] = tag >> 24; | |||
| AV_WL32(tagbuf, tag); | |||
| crc = crc32(crc, tagbuf, 4); | |||
| bytestream_put_be32(f, bswap_32(tag)); | |||
| if (length > 0) { | |||
| @@ -833,10 +830,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, | |||
| if (alpha && alpha != 0xff) | |||
| has_alpha = 1; | |||
| *alpha_ptr++ = alpha; | |||
| ptr[0] = v >> 16; | |||
| ptr[1] = v >> 8; | |||
| ptr[2] = v; | |||
| ptr += 3; | |||
| bytestream_put_be24(&ptr, v); | |||
| } | |||
| png_write_chunk(&s->bytestream, MKTAG('P', 'L', 'T', 'E'), s->buf, 256 * 3); | |||
| if (has_alpha) { | |||
| @@ -19,6 +19,7 @@ | |||
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |||
| */ | |||
| #include "avcodec.h" | |||
| #include "bytestream.h" | |||
| #include "pnm.h" | |||
| @@ -303,9 +304,7 @@ static int pam_encode_frame(AVCodecContext *avctx, unsigned char *outbuf, int bu | |||
| for(i=0;i<h;i++) { | |||
| for(j=0;j<w;j++) { | |||
| v = ((uint32_t *)ptr)[j]; | |||
| *s->bytestream++ = v >> 16; | |||
| *s->bytestream++ = v >> 8; | |||
| *s->bytestream++ = v; | |||
| bytestream_put_be24(&s->bytestream, v); | |||
| *s->bytestream++ = v >> 24; | |||
| } | |||
| ptr += linesize; | |||
| @@ -36,6 +36,7 @@ | |||
| #include "avcodec.h" | |||
| #include "rangecoder.h" | |||
| #include "bytestream.h" | |||
| void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size){ | |||
| @@ -53,8 +54,7 @@ void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size){ | |||
| /* cast to avoid compiler warning */ | |||
| ff_init_range_encoder(c, (uint8_t *) buf, buf_size); | |||
| c->low =(*c->bytestream++)<<8; | |||
| c->low+= *c->bytestream++; | |||
| c->low = bytestream_get_be16(&c->bytestream); | |||
| } | |||
| void ff_build_rac_states(RangeCoder *c, int factor, int max_p){ | |||
| @@ -436,11 +436,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8 | |||
| case 0: | |||
| for(i = 0; i < 4; i++) { | |||
| pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); | |||
| out[2] = pix & 0xFF; | |||
| out[3] = pix >> 8; | |||
| AV_WL16(out+2,pix); | |||
| pix = smk_get_code(&gb, smk->full_tbl, smk->full_last); | |||
| out[0] = pix & 0xFF; | |||
| out[1] = pix >> 8; | |||
| AV_WL16(out,pix); | |||
| out += stride; | |||
| } | |||
| break; | |||
| @@ -465,11 +463,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8 | |||
| uint16_t pix1, pix2; | |||
| pix1 = smk_get_code(&gb, smk->full_tbl, smk->full_last); | |||
| pix2 = smk_get_code(&gb, smk->full_tbl, smk->full_last); | |||
| out[0] = pix1 & 0xFF; out[1] = pix1 >> 8; | |||
| out[2] = pix2 & 0xFF; out[3] = pix2 >> 8; | |||
| AV_WL16(out,pix1); | |||
| AV_WL16(out+2,pix2); | |||
| out += stride; | |||
| out[0] = pix1 & 0xFF; out[1] = pix1 >> 8; | |||
| out[2] = pix2 & 0xFF; out[3] = pix2 >> 8; | |||
| AV_WL16(out,pix1); | |||
| AV_WL16(out+2,pix2); | |||
| out += stride; | |||
| } | |||
| break; | |||
| @@ -65,10 +65,8 @@ static int sp5x_decode_frame(AVCodecContext *avctx, | |||
| j += sizeof(sp5x_data_dht); | |||
| memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof)); | |||
| recoded[j+5] = (avctx->coded_height >> 8) & 0xFF; | |||
| recoded[j+6] = avctx->coded_height & 0xFF; | |||
| recoded[j+7] = (avctx->coded_width >> 8) & 0xFF; | |||
| recoded[j+8] = avctx->coded_width & 0xFF; | |||
| AV_WB16(recoded+j+5, avctx->coded_height); | |||
| AV_WB16(recoded+j+7, avctx->coded_width); | |||
| j += sizeof(sp5x_data_sof); | |||
| memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos)); | |||
| @@ -146,7 +146,7 @@ static void seqvideo_decode(SeqVideoContext *seq, unsigned char *data, int data_ | |||
| for (i = 0; i < 256; i++) { | |||
| for (j = 0; j < 3; j++, data++) | |||
| c[j] = (*data << 2) | (*data >> 4); | |||
| seq->palette[i] = (c[0] << 16) | (c[1] << 8) | c[2]; | |||
| seq->palette[i] = AV_RB24(c); | |||
| } | |||
| memcpy(seq->frame.data[1], seq->palette, sizeof(seq->palette)); | |||
| seq->frame.palette_has_changed = 1; | |||
| @@ -31,6 +31,7 @@ | |||
| #include <unistd.h> | |||
| #include "avcodec.h" | |||
| #include "bytestream.h" | |||
| #include "ulti_cb.h" | |||
| @@ -305,9 +306,7 @@ static int ulti_decode_frame(AVCodecContext *avctx, | |||
| case 2: | |||
| if (modifier) { // unpack four luma samples | |||
| tmp = (*buf++) << 16; | |||
| tmp += (*buf++) << 8; | |||
| tmp += *buf++; | |||
| tmp = bytestream_get_be24(&buf); | |||
| Y[0] = (tmp >> 18) & 0x3F; | |||
| Y[1] = (tmp >> 12) & 0x3F; | |||
| @@ -315,8 +314,7 @@ static int ulti_decode_frame(AVCodecContext *avctx, | |||
| Y[3] = tmp & 0x3F; | |||
| angle = 16; | |||
| } else { // retrieve luma samples from codebook | |||
| tmp = (*buf++) << 8; | |||
| tmp += (*buf++); | |||
| tmp = bytestream_get_be16(&buf); | |||
| angle = (tmp >> 12) & 0xF; | |||
| tmp &= 0xFFF; | |||
| @@ -332,33 +330,25 @@ static int ulti_decode_frame(AVCodecContext *avctx, | |||
| if (modifier) { // all 16 luma samples | |||
| uint8_t Luma[16]; | |||
| tmp = (*buf++) << 16; | |||
| tmp += (*buf++) << 8; | |||
| tmp += *buf++; | |||
| tmp = bytestream_get_be24(&buf); | |||
| Luma[0] = (tmp >> 18) & 0x3F; | |||
| Luma[1] = (tmp >> 12) & 0x3F; | |||
| Luma[2] = (tmp >> 6) & 0x3F; | |||
| Luma[3] = tmp & 0x3F; | |||
| tmp = (*buf++) << 16; | |||
| tmp += (*buf++) << 8; | |||
| tmp += *buf++; | |||
| tmp = bytestream_get_be24(&buf); | |||
| Luma[4] = (tmp >> 18) & 0x3F; | |||
| Luma[5] = (tmp >> 12) & 0x3F; | |||
| Luma[6] = (tmp >> 6) & 0x3F; | |||
| Luma[7] = tmp & 0x3F; | |||
| tmp = (*buf++) << 16; | |||
| tmp += (*buf++) << 8; | |||
| tmp += *buf++; | |||
| tmp = bytestream_get_be24(&buf); | |||
| Luma[8] = (tmp >> 18) & 0x3F; | |||
| Luma[9] = (tmp >> 12) & 0x3F; | |||
| Luma[10] = (tmp >> 6) & 0x3F; | |||
| Luma[11] = tmp & 0x3F; | |||
| tmp = (*buf++) << 16; | |||
| tmp += (*buf++) << 8; | |||
| tmp += *buf++; | |||
| tmp = bytestream_get_be24(&buf); | |||
| Luma[12] = (tmp >> 18) & 0x3F; | |||
| Luma[13] = (tmp >> 12) & 0x3F; | |||
| Luma[14] = (tmp >> 6) & 0x3F; | |||
| @@ -27,6 +27,7 @@ | |||
| #include "vp56data.h" | |||
| #include "dsputil.h" | |||
| #include "mpegvideo.h" | |||
| #include "bytestream.h" | |||
| typedef struct vp56_context vp56_context_t; | |||
| @@ -169,8 +170,7 @@ static inline void vp56_init_range_decoder(vp56_range_coder_t *c, | |||
| c->high = 255; | |||
| c->bits = 8; | |||
| c->buffer = buf; | |||
| c->code_word = *c->buffer++ << 8; | |||
| c->code_word |= *c->buffer++; | |||
| c->code_word = bytestream_get_be16(&c->buffer); | |||
| } | |||
| static inline int vp56_rac_get_prob(vp56_range_coder_t *c, uint8_t prob) | |||
| @@ -92,12 +92,11 @@ static int wma_decode_init(AVCodecContext * avctx) | |||
| flags2 = 0; | |||
| extradata = avctx->extradata; | |||
| if (avctx->codec->id == CODEC_ID_WMAV1 && avctx->extradata_size >= 4) { | |||
| flags1 = extradata[0] | (extradata[1] << 8); | |||
| flags2 = extradata[2] | (extradata[3] << 8); | |||
| flags1 = AV_RL16(extradata); | |||
| flags2 = AV_RL16(extradata+2); | |||
| } else if (avctx->codec->id == CODEC_ID_WMAV2 && avctx->extradata_size >= 6) { | |||
| flags1 = extradata[0] | (extradata[1] << 8) | | |||
| (extradata[2] << 16) | (extradata[3] << 24); | |||
| flags2 = extradata[4] | (extradata[5] << 8); | |||
| flags1 = AV_RL32(extradata); | |||
| flags2 = AV_RL16(extradata+4); | |||
| } | |||
| // for(i=0; i<avctx->extradata_size; i++) | |||
| // av_log(NULL, AV_LOG_ERROR, "%02X ", extradata[i]); | |||
| @@ -45,19 +45,13 @@ static int encode_init(AVCodecContext * avctx){ | |||
| if (avctx->codec->id == CODEC_ID_WMAV1) { | |||
| extradata= av_malloc(4); | |||
| avctx->extradata_size= 4; | |||
| extradata[0] = flags1; | |||
| extradata[1] = flags1>>8; | |||
| extradata[2] = flags2; | |||
| extradata[3] = flags2>>8; | |||
| AV_WL16(extradata, flags1); | |||
| AV_WL16(extradata+2, flags2); | |||
| } else if (avctx->codec->id == CODEC_ID_WMAV2) { | |||
| extradata= av_mallocz(10); | |||
| avctx->extradata_size= 10; | |||
| extradata[0] = flags1; | |||
| extradata[1] = flags1>>8; | |||
| extradata[2] = flags1>>16; | |||
| extradata[3] = flags1>>24; | |||
| extradata[4] = flags2; | |||
| extradata[5] = flags2>>8; | |||
| AV_WL32(extradata, flags1); | |||
| AV_WL16(extradata+4, flags2); | |||
| }else | |||
| assert(0); | |||
| avctx->extradata= extradata; | |||
| @@ -354,8 +354,7 @@ static void xan_wc3_decode_frame(XanContext *s) { | |||
| case 11: | |||
| case 21: | |||
| size = (size_segment[0] << 16) | (size_segment[1] << 8) | | |||
| size_segment[2]; | |||
| size = AV_RB24(size_segment); | |||
| size_segment += 3; | |||
| break; | |||
| } | |||
| @@ -579,9 +579,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8 | |||
| for(i = 0; i < c->width; i++) { | |||
| uint32_t tmp = AV_RL32(src); | |||
| src += 4; | |||
| out[i * 3 + 0] = tmp >> 16; | |||
| out[i * 3 + 1] = tmp >> 8; | |||
| out[i * 3 + 2] = tmp >> 0; | |||
| AV_WB24(out+(i*3), tmp); | |||
| } | |||
| out += c->pic.linesize[0]; | |||
| } | |||
| @@ -144,9 +144,7 @@ static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void | |||
| if(chpal){ | |||
| uint8_t tpal[3]; | |||
| for(i = 0; i < 256; i++){ | |||
| tpal[0] = palptr[i] >> 16; | |||
| tpal[1] = palptr[i] >> 8; | |||
| tpal[2] = palptr[i]; | |||
| AV_WB24(tpal, palptr[i]); | |||
| c->work_buf[work_size++] = tpal[0] ^ c->pal[i * 3 + 0]; | |||
| c->work_buf[work_size++] = tpal[1] ^ c->pal[i * 3 + 1]; | |||
| c->work_buf[work_size++] = tpal[2] ^ c->pal[i * 3 + 2]; | |||
| @@ -158,9 +156,7 @@ static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void | |||
| } | |||
| if(keyframe){ | |||
| for(i = 0; i < 256; i++){ | |||
| c->pal[i*3 + 0] = palptr[i] >> 16; | |||
| c->pal[i*3 + 1] = palptr[i] >> 8; | |||
| c->pal[i*3 + 2] = palptr[i]; | |||
| AV_WB24(c->pal+(i*3), palptr[i]); | |||
| } | |||
| memcpy(c->work_buf, c->pal, 768); | |||
| memcpy(c->pal2, p->data[1], 1024); | |||