Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master:
  x86: dsputil: prettyprint gcc inline asm
  x86: K&R prettyprinting cosmetics for dsputil_mmx.c
  x86: conditionally compile H.264 QPEL optimizations
  dsputil_mmx: Surround QPEL macros by "do { } while (0);" blocks.
  Ignore generated files below doc/.
  dpcm: convert to bytestream2.
  interplayvideo: convert to bytestream2.
  movenc: Merge if statements
  h264: fix memleak in error path.
  pthread: Immediately release all frames in ff_thread_flush()
  h264: Add check for invalid chroma_format_idc
  utvideo: port header reading to bytestream2.

Conflicts:
	.gitignore
	configure
	libavcodec/h264_ps.c
	libavcodec/interplayvideo.c
	libavcodec/pthread.c
	libavcodec/x86/dsputil_mmx.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/4/head
Michael Niedermayer 13 years ago
parent 8d7f2db60a 62ce9defb8
commit 9621646eb3
10 changed files with 2484 additions and 2247 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      .gitignore
  2. 15
      configure
  3. 58
      libavcodec/dpcm.c
  4. 4
      libavcodec/h264_ps.c
  5. 323
      libavcodec/interplayvideo.c
  6. 10
      libavcodec/pthread.c
  7. 28
      libavcodec/utvideo.c
  8. 2
      libavcodec/x86/Makefile
  9. 4281
      libavcodec/x86/dsputil_mmx.c
  10. 7
      libavformat/movenc.c

3
.gitignore vendored
Unescape View File

@ -22,6 +22,9 @@ ffplay
ffprobe
ffserver
avconv
doc/avoptions_codec.texi
doc/avoptions_format.texi
doc/print_options
libavcodec/*_tablegen
libavcodec/*_tables.c
libavcodec/*_tables.h

15
configure vendored
Unescape View File

@ -1266,6 +1266,7 @@ CONFIG_EXTRA="
h264chroma
h264dsp
h264pred
h264qpel
huffman
lgplv3
lpc
@ -1424,7 +1425,7 @@ h263_vaapi_hwaccel_select="vaapi h263_decoder"
h263i_decoder_select="h263_decoder"
h263p_encoder_select="h263_encoder"
h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
h264_decoder_select="golomb h264chroma h264dsp h264pred"
h264_decoder_select="golomb h264chroma h264dsp h264pred h264qpel"
h264_dxva2_hwaccel_deps="dxva2api_h"
h264_dxva2_hwaccel_select="dxva2 h264_decoder"
h264_vaapi_hwaccel_select="vaapi h264_decoder"
@ -1485,8 +1486,8 @@ rv10_decoder_select="h263_decoder"
rv10_encoder_select="h263_encoder"
rv20_decoder_select="h263_decoder"
rv20_encoder_select="h263_encoder"
rv30_decoder_select="golomb h264chroma h264pred"
rv40_decoder_select="golomb h264chroma h264pred"
rv30_decoder_select="golomb h264chroma h264pred h264qpel"
rv40_decoder_select="golomb h264chroma h264pred h264qpel"
shorten_decoder_select="golomb"
sipr_decoder_select="lsp"
snow_decoder_select="dwt"
@ -1495,7 +1496,7 @@ sonic_decoder_select="golomb"
sonic_encoder_select="golomb"
sonic_ls_encoder_select="golomb"
svq1_encoder_select="aandct"
svq3_decoder_select="golomb h264chroma h264dsp h264pred"
svq3_decoder_select="golomb h264chroma h264dsp h264pred h264qpel"
svq3_decoder_suggest="zlib"
theora_decoder_select="vp3_decoder"
tiff_decoder_suggest="zlib"
@ -1504,7 +1505,7 @@ truehd_decoder_select="mlp_decoder"
tscc_decoder_select="zlib"
twinvq_decoder_select="mdct lsp sinewin"
vc1_crystalhd_decoder_select="crystalhd"
vc1_decoder_select="h263_decoder h264chroma"
vc1_decoder_select="h263_decoder h264chroma h264qpel"
vc1_dxva2_hwaccel_deps="dxva2api_h"
vc1_dxva2_hwaccel_select="dxva2 vc1_decoder"
vc1_vaapi_hwaccel_select="vaapi vc1_decoder"
@ -1515,7 +1516,7 @@ vorbis_encoder_select="mdct"
vp6_decoder_select="huffman"
vp6a_decoder_select="vp6_decoder"
vp6f_decoder_select="vp6_decoder"
vp8_decoder_select="h264pred"
vp8_decoder_select="h264pred h264qpel"
wmapro_decoder_select="mdct sinewin"
wmav1_decoder_select="mdct sinewin"
wmav1_encoder_select="mdct sinewin"
@ -1544,7 +1545,7 @@ vda_deps="VideoDecodeAcceleration_VDADecoder_h pthreads"
vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"
# parsers
h264_parser_select="golomb h264chroma h264dsp h264pred"
h264_parser_select="golomb h264chroma h264dsp h264pred h264qpel"
# external libraries
libaacplus_encoder_deps="libaacplus"

58
libavcodec/dpcm.c
Unescape View File

@ -40,6 +40,7 @@
#include "libavutil/intreadwrite.h"
#include "avcodec.h"
#include "bytestream.h"
#include "mathops.h"
typedef struct DPCMContext {
AVFrame frame;
@ -173,20 +174,18 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
const uint8_t *buf_end = buf + buf_size;
DPCMContext *s = avctx->priv_data;
int out = 0, ret;
int predictor[2];
int ch = 0;
int stereo = s->channels - 1;
int16_t *output_samples;
int16_t *output_samples, *samples_end;
GetByteContext gb;
if (stereo && (buf_size & 1)) {
if (stereo && (buf_size & 1))
buf_size--;
buf_end--;
}
bytestream2_init(&gb, avpkt->data, buf_size);
/* calculate output size */
switch(avctx->codec->id) {
@ -221,22 +220,23 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
return ret;
}
output_samples = (int16_t *)s->frame.data[0];
samples_end = output_samples + out;
switch(avctx->codec->id) {
case CODEC_ID_ROQ_DPCM:
buf += 6;
bytestream2_skipu(&gb, 6);
if (stereo) {
predictor[1] = (int16_t)(bytestream_get_byte(&buf) << 8);
predictor[0] = (int16_t)(bytestream_get_byte(&buf) << 8);
predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
} else {
predictor[0] = (int16_t)bytestream_get_le16(&buf);
predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
}
/* decode the samples */
while (buf < buf_end) {
predictor[ch] += s->roq_square_array[*buf++];
while (output_samples < samples_end) {
predictor[ch] += s->roq_square_array[bytestream2_get_byteu(&gb)];
predictor[ch] = av_clip_int16(predictor[ch]);
*output_samples++ = predictor[ch];
@ -246,16 +246,16 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
break;
case CODEC_ID_INTERPLAY_DPCM:
buf += 6; /* skip over the stream mask and stream length */
bytestream2_skipu(&gb, 6); /* skip over the stream mask and stream length */
for (ch = 0; ch < s->channels; ch++) {
predictor[ch] = (int16_t)bytestream_get_le16(&buf);
predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
*output_samples++ = predictor[ch];
}
ch = 0;
while (buf < buf_end) {
predictor[ch] += interplay_delta_table[*buf++];
while (output_samples < samples_end) {
predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
predictor[ch] = av_clip_int16(predictor[ch]);
*output_samples++ = predictor[ch];
@ -269,16 +269,19 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
int shift[2] = { 4, 4 };
for (ch = 0; ch < s->channels; ch++)
predictor[ch] = (int16_t)bytestream_get_le16(&buf);
predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
ch = 0;
while (buf < buf_end) {
uint8_t n = *buf++;
int16_t diff = (n & 0xFC) << 8;
if ((n & 0x03) == 3)
while (output_samples < samples_end) {
int diff = bytestream2_get_byteu(&gb);
int n = diff & 3;
if (n == 3)
shift[ch]++;
else
shift[ch] -= (2 * (n & 3));
shift[ch] -= (2 * n);
diff = sign_extend((diff &~ 3) << 8, 16);
/* saturate the shifter to a lower limit of 0 */
if (shift[ch] < 0)
shift[ch] = 0;
@ -296,9 +299,10 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
}
case CODEC_ID_SOL_DPCM:
if (avctx->codec_tag != 3) {
uint8_t *output_samples_u8 = s->frame.data[0];
while (buf < buf_end) {
uint8_t n = *buf++;
uint8_t *output_samples_u8 = s->frame.data[0],
*samples_end_u8 = output_samples_u8 + out;
while (output_samples_u8 < samples_end_u8) {
int n = bytestream2_get_byteu(&gb);
s->sample[0] += s->sol_table[n >> 4];
s->sample[0] = av_clip_uint8(s->sample[0]);
@ -309,8 +313,8 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
*output_samples_u8++ = s->sample[stereo];
}
} else {
while (buf < buf_end) {
uint8_t n = *buf++;
while (output_samples < samples_end) {
int n = bytestream2_get_byteu(&gb);
if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
else s->sample[ch] += sol_table_16[n & 0x7F];
s->sample[ch] = av_clip_int16(s->sample[ch]);

4
libavcodec/h264_ps.c
Unescape View File

@ -352,9 +352,9 @@ int ff_h264_decode_seq_parameter_set(H264Context *h){
if (sps->chroma_format_idc > 3U) {
av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
goto fail;
}
if(sps->chroma_format_idc == 3)
} else if(sps->chroma_format_idc == 3) {
sps->residual_color_transform_flag = get_bits1(&s->gb);
}
sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
if (sps->bit_depth_luma > 12U || sps->bit_depth_chroma > 12U) {

323
libavcodec/interplayvideo.c
Unescape View File

@ -56,14 +56,8 @@ typedef struct IpvideoContext {
const unsigned char *decoding_map;
int decoding_map_size;
const unsigned char *buf;
int size;
int is_16bpp;
const unsigned char *stream_ptr;
const unsigned char *stream_end;
const uint8_t *mv_ptr;
const uint8_t *mv_end;
GetByteContext stream_ptr, mv_ptr;
unsigned char *pixel_ptr;
int line_inc;
int stride;
@ -72,13 +66,6 @@ typedef struct IpvideoContext {
uint32_t pal[256];
} IpvideoContext;
#define CHECK_STREAM_PTR(stream_ptr, stream_end, n) \
if (stream_end - stream_ptr < n) { \
av_log(s->avctx, AV_LOG_ERROR, "stream_ptr out of bounds (%p >= %p)\n", \
stream_ptr + n, stream_end); \
return -1; \
}
static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y)
{
int current_offset = s->pixel_ptr - s->current_frame.data[0];
@ -118,11 +105,9 @@ static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)
/* copy block from 2 frames ago using a motion vector; need 1 more byte */
if (!s->is_16bpp) {
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
B = *s->stream_ptr++;
B = bytestream2_get_byte(&s->stream_ptr);
} else {
CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
B = *s->mv_ptr++;
B = bytestream2_get_byte(&s->mv_ptr);
}
if (B < 56) {
@ -146,11 +131,9 @@ static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)
/* need 1 more byte for motion */
if (!s->is_16bpp) {
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
B = *s->stream_ptr++;
B = bytestream2_get_byte(&s->stream_ptr);
} else {
CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
B = *s->mv_ptr++;
B = bytestream2_get_byte(&s->mv_ptr);
}
if (B < 56) {
@ -172,11 +155,9 @@ static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)
/* copy a block from the previous frame; need 1 more byte */
if (!s->is_16bpp) {
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
B = *s->stream_ptr++;
B = bytestream2_get_byte(&s->stream_ptr);
} else {
CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
B = *s->mv_ptr++;
B = bytestream2_get_byte(&s->mv_ptr);
}
BL = B & 0x0F;
@ -194,10 +175,8 @@ static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)
/* copy a block from the previous frame using an expanded range;
* need 2 more bytes */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
x = *s->stream_ptr++;
y = *s->stream_ptr++;
x = bytestream2_get_byte(&s->stream_ptr);
y = bytestream2_get_byte(&s->stream_ptr);
av_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);
return copy_from(s, &s->last_frame, x, y);
@ -219,18 +198,14 @@ static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
unsigned int flags;
/* 2-color encoding */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
P[0] = *s->stream_ptr++;
P[1] = *s->stream_ptr++;
P[0] = bytestream2_get_byte(&s->stream_ptr);
P[1] = bytestream2_get_byte(&s->stream_ptr);
if (P[0] <= P[1]) {
/* need 8 more bytes from the stream */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
for (y = 0; y < 8; y++) {
flags = *s->stream_ptr++ | 0x100;
flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;
for (; flags != 1; flags >>= 1)
*s->pixel_ptr++ = P[flags & 1];
s->pixel_ptr += s->line_inc;
@ -239,9 +214,7 @@ static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
} else {
/* need 2 more bytes from the stream */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
flags = bytestream_get_le16(&s->stream_ptr);
flags = bytestream2_get_le16(&s->stream_ptr);
for (y = 0; y < 8; y += 2) {
for (x = 0; x < 8; x += 2, flags >>= 1) {
s->pixel_ptr[x ] =
@ -260,26 +233,23 @@ static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
{
int x, y;
unsigned char P[2];
unsigned char P[4];
unsigned int flags = 0;
/* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
* either top and bottom or left and right halves */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
P[0] = *s->stream_ptr++;
P[1] = *s->stream_ptr++;
P[0] = bytestream2_get_byte(&s->stream_ptr);
P[1] = bytestream2_get_byte(&s->stream_ptr);
if (P[0] <= P[1]) {
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 14);
s->stream_ptr -= 2;
for (y = 0; y < 16; y++) {
// new values for each 4x4 block
if (!(y & 3)) {
P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
flags = bytestream_get_le16(&s->stream_ptr);
if (y) {
P[0] = bytestream2_get_byte(&s->stream_ptr);
P[1] = bytestream2_get_byte(&s->stream_ptr);
}
flags = bytestream2_get_le16(&s->stream_ptr);
}
for (x = 0; x < 4; x++, flags >>= 1)
@ -290,13 +260,11 @@ static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
}
} else {
flags = bytestream2_get_le32(&s->stream_ptr);
P[2] = bytestream2_get_byte(&s->stream_ptr);
P[3] = bytestream2_get_byte(&s->stream_ptr);
/* need 10 more bytes */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 10);
if (s->stream_ptr[4] <= s->stream_ptr[5]) {
flags = bytestream_get_le32(&s->stream_ptr);
if (P[2] <= P[3]) {
/* vertical split; left & right halves are 2-color encoded */
@ -307,8 +275,9 @@ static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
// switch to right half
if (y == 7) {
s->pixel_ptr -= 8 * s->stride - 4;
P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
flags = bytestream_get_le32(&s->stream_ptr);
P[0] = P[2];
P[1] = P[3];
flags = bytestream2_get_le32(&s->stream_ptr);
}
}
@ -318,12 +287,12 @@ static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
for (y = 0; y < 8; y++) {
if (y == 4) {
P[0] = *s->stream_ptr++;
P[1] = *s->stream_ptr++;
P[0] = P[2];
P[1] = P[3];
flags = bytestream2_get_le32(&s->stream_ptr);
}
flags = *s->stream_ptr++ | 0x100;
for (; flags != 1; flags >>= 1)
for (x = 0; x < 8; x++, flags >>= 1)
*s->pixel_ptr++ = P[flags & 1];
s->pixel_ptr += s->line_inc;
}
@ -340,20 +309,15 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
unsigned char P[4];
/* 4-color encoding */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
memcpy(P, s->stream_ptr, 4);
s->stream_ptr += 4;
bytestream2_get_buffer(&s->stream_ptr, P, 4);
if (P[0] <= P[1]) {
if (P[2] <= P[3]) {
/* 1 of 4 colors for each pixel, need 16 more bytes */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);
for (y = 0; y < 8; y++) {
/* get the next set of 8 2-bit flags */
int flags = bytestream_get_le16(&s->stream_ptr);
int flags = bytestream2_get_le16(&s->stream_ptr);
for (x = 0; x < 8; x++, flags >>= 2)
*s->pixel_ptr++ = P[flags & 0x03];
s->pixel_ptr += s->line_inc;
@ -363,9 +327,7 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
uint32_t flags;
/* 1 of 4 colors for each 2x2 block, need 4 more bytes */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
flags = bytestream_get_le32(&s->stream_ptr);
flags = bytestream2_get_le32(&s->stream_ptr);
for (y = 0; y < 8; y += 2) {
for (x = 0; x < 8; x += 2, flags >>= 2) {
@ -382,9 +344,7 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
uint64_t flags;
/* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
flags = bytestream_get_le64(&s->stream_ptr);
flags = bytestream2_get_le64(&s->stream_ptr);
if (P[2] <= P[3]) {
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x += 2, flags >>= 2) {
@ -411,24 +371,21 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
{
int x, y;
unsigned char P[4];
unsigned char P[8];
int flags = 0;
bytestream2_get_buffer(&s->stream_ptr, P, 4);
/* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
* either top and bottom or left and right halves */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);
if (s->stream_ptr[0] <= s->stream_ptr[1]) {
if (P[0] <= P[1]) {
/* 4-color encoding for each quadrant; need 32 bytes */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32);
for (y = 0; y < 16; y++) {
// new values for each 4x4 block
if (!(y & 3)) {
memcpy(P, s->stream_ptr, 4);
s->stream_ptr += 4;
flags = bytestream_get_le32(&s->stream_ptr);
if (y) bytestream2_get_buffer(&s->stream_ptr, P, 4);
flags = bytestream2_get_le32(&s->stream_ptr);
}
for (x = 0; x < 4; x++, flags >>= 2)
@ -441,20 +398,16 @@ static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
} else {
// vertical split?
int vert = s->stream_ptr[12] <= s->stream_ptr[13];
uint64_t flags = 0;
int vert;
uint64_t flags = bytestream2_get_le64(&s->stream_ptr);
bytestream2_get_buffer(&s->stream_ptr, P + 4, 4);
vert = P[4] <= P[5];
/* 4-color encoding for either left and right or top and bottom
* halves */
for (y = 0; y < 16; y++) {
// load values for each half
if (!(y & 7)) {
memcpy(P, s->stream_ptr, 4);
s->stream_ptr += 4;
flags = bytestream_get_le64(&s->stream_ptr);
}
for (x = 0; x < 4; x++, flags >>= 2)
*s->pixel_ptr++ = P[flags & 0x03];
@ -463,6 +416,12 @@ static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
// switch to right half
if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
} else if (y & 1) s->pixel_ptr += s->line_inc;
// load values for second half
if (y == 7) {
memcpy(P, P + 4, 4);
flags = bytestream2_get_le64(&s->stream_ptr);
}
}
}
@ -475,11 +434,8 @@ static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
int y;
/* 64-color encoding (each pixel in block is a different color) */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 64);
for (y = 0; y < 8; y++) {
memcpy(s->pixel_ptr, s->stream_ptr, 8);
s->stream_ptr += 8;
bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);
s->pixel_ptr += s->stride;
}
@ -492,14 +448,12 @@ static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
int x, y;
/* 16-color block encoding: each 2x2 block is a different color */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);
for (y = 0; y < 8; y += 2) {
for (x = 0; x < 8; x += 2) {
s->pixel_ptr[x ] =
s->pixel_ptr[x + 1 ] =
s->pixel_ptr[x + s->stride] =
s->pixel_ptr[x + 1 + s->stride] = *s->stream_ptr++;
s->pixel_ptr[x + 1 + s->stride] = bytestream2_get_byte(&s->stream_ptr);
}
s->pixel_ptr += s->stride * 2;
}
@ -514,12 +468,10 @@ static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
unsigned char P[2];
/* 4-color block encoding: each 4x4 block is a different color */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
for (y = 0; y < 8; y++) {
if (!(y & 3)) {
P[0] = *s->stream_ptr++;
P[1] = *s->stream_ptr++;
P[0] = bytestream2_get_byte(&s->stream_ptr);
P[1] = bytestream2_get_byte(&s->stream_ptr);
}
memset(s->pixel_ptr, P[0], 4);
memset(s->pixel_ptr + 4, P[1], 4);
@ -536,8 +488,7 @@ static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
unsigned char pix;
/* 1-color encoding: the whole block is 1 solid color */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
pix = *s->stream_ptr++;
pix = bytestream2_get_byte(&s->stream_ptr);
for (y = 0; y < 8; y++) {
memset(s->pixel_ptr, pix, 8);
@ -554,9 +505,8 @@ static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
unsigned char sample[2];
/* dithered encoding */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
sample[0] = *s->stream_ptr++;
sample[1] = *s->stream_ptr++;
sample[0] = bytestream2_get_byte(&s->stream_ptr);
sample[1] = bytestream2_get_byte(&s->stream_ptr);
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x += 2) {
@ -575,10 +525,8 @@ static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s)
signed char x, y;
/* copy a block from the second last frame using an expanded range */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
x = *s->stream_ptr++;
y = *s->stream_ptr++;
x = bytestream2_get_byte(&s->stream_ptr);
y = bytestream2_get_byte(&s->stream_ptr);
av_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);
return copy_from(s, &s->second_last_frame, x, y);
@ -592,17 +540,13 @@ static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)
uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
/* 2-color encoding */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
P[0] = bytestream_get_le16(&s->stream_ptr);
P[1] = bytestream_get_le16(&s->stream_ptr);
P[0] = bytestream2_get_le16(&s->stream_ptr);
P[1] = bytestream2_get_le16(&s->stream_ptr);
if (!(P[0] & 0x8000)) {
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
for (y = 0; y < 8; y++) {
flags = *s->stream_ptr++ | 0x100;
flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;
for (; flags != 1; flags >>= 1)
*pixel_ptr++ = P[flags & 1];
pixel_ptr += s->line_inc;
@ -610,9 +554,7 @@ static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)
} else {
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
flags = bytestream_get_le16(&s->stream_ptr);
flags = bytestream2_get_le16(&s->stream_ptr);
for (y = 0; y < 8; y += 2) {
for (x = 0; x < 8; x += 2, flags >>= 1) {
pixel_ptr[x ] =
@ -630,28 +572,25 @@ static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)
static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)
{
int x, y;
uint16_t P[2];
uint16_t P[4];
unsigned int flags = 0;
uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
/* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
* either top and bottom or left and right halves */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
P[0] = bytestream_get_le16(&s->stream_ptr);
P[1] = bytestream_get_le16(&s->stream_ptr);
P[0] = bytestream2_get_le16(&s->stream_ptr);
P[1] = bytestream2_get_le16(&s->stream_ptr);
if (!(P[0] & 0x8000)) {
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);
s->stream_ptr -= 4;
for (y = 0; y < 16; y++) {
// new values for each 4x4 block
if (!(y & 3)) {
P[0] = bytestream_get_le16(&s->stream_ptr);
P[1] = bytestream_get_le16(&s->stream_ptr);
flags = bytestream_get_le16(&s->stream_ptr);
if (y) {
P[0] = bytestream2_get_le16(&s->stream_ptr);
P[1] = bytestream2_get_le16(&s->stream_ptr);
}
flags = bytestream2_get_le16(&s->stream_ptr);
}
for (x = 0; x < 4; x++, flags >>= 1)
@ -663,11 +602,11 @@ static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)
} else {
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 12);
if (!(AV_RL16(s->stream_ptr + 4) & 0x8000)) {
flags = bytestream2_get_le32(&s->stream_ptr);
P[2] = bytestream2_get_le16(&s->stream_ptr);
P[3] = bytestream2_get_le16(&s->stream_ptr);
flags = bytestream_get_le32(&s->stream_ptr);
if (!(P[2] & 0x8000)) {
/* vertical split; left & right halves are 2-color encoded */
@ -678,9 +617,9 @@ static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)
// switch to right half
if (y == 7) {
pixel_ptr -= 8 * s->stride - 4;
P[0] = bytestream_get_le16(&s->stream_ptr);
P[1] = bytestream_get_le16(&s->stream_ptr);
flags = bytestream_get_le32(&s->stream_ptr);
P[0] = P[2];
P[1] = P[3];
flags = bytestream2_get_le32(&s->stream_ptr);
}
}
@ -690,12 +629,12 @@ static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)
for (y = 0; y < 8; y++) {
if (y == 4) {
P[0] = bytestream_get_le16(&s->stream_ptr);
P[1] = bytestream_get_le16(&s->stream_ptr);
P[0] = P[2];
P[1] = P[3];
flags = bytestream2_get_le32(&s->stream_ptr);
}
flags = *s->stream_ptr++ | 0x100;
for (; flags != 1; flags >>= 1)
for (x = 0; x < 8; x++, flags >>= 1)
*pixel_ptr++ = P[flags & 1];
pixel_ptr += s->line_inc;
}
@ -713,20 +652,16 @@ static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)
uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
/* 4-color encoding */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
for (x = 0; x < 4; x++)
P[x] = bytestream_get_le16(&s->stream_ptr);
P[x] = bytestream2_get_le16(&s->stream_ptr);
if (!(P[0] & 0x8000)) {
if (!(P[2] & 0x8000)) {
/* 1 of 4 colors for each pixel */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);
for (y = 0; y < 8; y++) {
/* get the next set of 8 2-bit flags */
int flags = bytestream_get_le16(&s->stream_ptr);
int flags = bytestream2_get_le16(&s->stream_ptr);
for (x = 0; x < 8; x++, flags >>= 2)
*pixel_ptr++ = P[flags & 0x03];
pixel_ptr += s->line_inc;
@ -736,9 +671,7 @@ static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)
uint32_t flags;
/* 1 of 4 colors for each 2x2 block */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
flags = bytestream_get_le32(&s->stream_ptr);
flags = bytestream2_get_le32(&s->stream_ptr);
for (y = 0; y < 8; y += 2) {
for (x = 0; x < 8; x += 2, flags >>= 2) {
@ -755,9 +688,7 @@ static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)
uint64_t flags;
/* 1 of 4 colors for each 2x1 or 1x2 block */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
flags = bytestream_get_le64(&s->stream_ptr);
flags = bytestream2_get_le64(&s->stream_ptr);
if (!(P[2] & 0x8000)) {
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x += 2, flags >>= 2) {
@ -784,25 +715,25 @@ static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)
static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)
{
int x, y;
uint16_t P[4];
uint16_t P[8];
int flags = 0;
uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
for (x = 0; x < 4; x++)
P[x] = bytestream2_get_le16(&s->stream_ptr);
/* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
* either top and bottom or left and right halves */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);
if (!(AV_RL16(s->stream_ptr) & 0x8000)) {
if (!(P[0] & 0x8000)) {
/* 4-color encoding for each quadrant */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 48);
for (y = 0; y < 16; y++) {
// new values for each 4x4 block
if (!(y & 3)) {
for (x = 0; x < 4; x++)
P[x] = bytestream_get_le16(&s->stream_ptr);
flags = bytestream_get_le32(&s->stream_ptr);
if (y)
for (x = 0; x < 4; x++)
P[x] = bytestream2_get_le16(&s->stream_ptr);
flags = bytestream2_get_le32(&s->stream_ptr);
}
for (x = 0; x < 4; x++, flags >>= 2)
@ -815,20 +746,17 @@ static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)
} else {
// vertical split?
int vert = !(AV_RL16(s->stream_ptr + 16) & 0x8000);
uint64_t flags = 0;
int vert;
uint64_t flags = bytestream2_get_le64(&s->stream_ptr);
for (x = 4; x < 8; x++)
P[x] = bytestream2_get_le16(&s->stream_ptr);
vert = !(P[4] & 0x8000);
/* 4-color encoding for either left and right or top and bottom
* halves */
for (y = 0; y < 16; y++) {
// load values for each half
if (!(y & 7)) {
for (x = 0; x < 4; x++)
P[x] = bytestream_get_le16(&s->stream_ptr);
flags = bytestream_get_le64(&s->stream_ptr);
}
for (x = 0; x < 4; x++, flags >>= 2)
*pixel_ptr++ = P[flags & 0x03];
@ -837,6 +765,12 @@ static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)
// switch to right half
if (y == 7) pixel_ptr -= 8 * s->stride - 4;
} else if (y & 1) pixel_ptr += s->line_inc;
// load values for second half
if (y == 7) {
memcpy(P, P + 4, 8);
flags = bytestream2_get_le64(&s->stream_ptr);
}
}
}
@ -850,11 +784,9 @@ static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s)
uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
/* 64-color encoding (each pixel in block is a different color) */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 128);
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++)
pixel_ptr[x] = bytestream_get_le16(&s->stream_ptr);
pixel_ptr[x] = bytestream2_get_le16(&s->stream_ptr);
pixel_ptr += s->stride;
}
@ -868,14 +800,12 @@ static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s)
uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
/* 16-color block encoding: each 2x2 block is a different color */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32);
for (y = 0; y < 8; y += 2) {
for (x = 0; x < 8; x += 2) {
pixel_ptr[x ] =
pixel_ptr[x + 1 ] =
pixel_ptr[x + s->stride] =
pixel_ptr[x + 1 + s->stride] = bytestream_get_le16(&s->stream_ptr);
pixel_ptr[x + 1 + s->stride] = bytestream2_get_le16(&s->stream_ptr);
}
pixel_ptr += s->stride * 2;
}
@ -891,12 +821,10 @@ static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext *s)
uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
/* 4-color block encoding: each 4x4 block is a different color */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
for (y = 0; y < 8; y++) {
if (!(y & 3)) {
P[0] = bytestream_get_le16(&s->stream_ptr);
P[1] = bytestream_get_le16(&s->stream_ptr);
P[0] = bytestream2_get_le16(&s->stream_ptr);
P[1] = bytestream2_get_le16(&s->stream_ptr);
}
for (x = 0; x < 8; x++)
pixel_ptr[x] = P[x >> 2];
@ -914,8 +842,7 @@ static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext *s)
uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
/* 1-color encoding: the whole block is 1 solid color */
CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
pix = bytestream_get_le16(&s->stream_ptr);
pix = bytestream2_get_le16(&s->stream_ptr);
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++)
@ -960,19 +887,16 @@ static void ipvideo_decode_opcodes(IpvideoContext *s)
av_dlog(s->avctx, "frame %d\n", frame);
frame++;
bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */
if (!s->is_16bpp) {
/* this is PAL8, so make the palette available */
memcpy(s->current_frame.data[1], s->pal, AVPALETTE_SIZE);
s->stride = s->current_frame.linesize[0];
s->stream_ptr = s->buf + 14; /* data starts 14 bytes in */
s->stream_end = s->buf + s->size;
} else {
s->stride = s->current_frame.linesize[0] >> 1;
s->stream_ptr = s->buf + 16;
s->stream_end =
s->mv_ptr = s->buf + 14 + AV_RL16(s->buf+14);
s->mv_end = s->buf + s->size;
s->mv_ptr = s->stream_ptr;
bytestream2_skip(&s->mv_ptr, bytestream2_get_le16(&s->stream_ptr));
}
s->line_inc = s->stride - 8;
s->upper_motion_limit_offset = (s->avctx->height - 8) * s->current_frame.linesize[0]
@ -1002,9 +926,10 @@ static void ipvideo_decode_opcodes(IpvideoContext *s)
}
}
}
if (s->stream_end - s->stream_ptr > 1) {
av_log(s->avctx, AV_LOG_ERROR, "decode finished with %td bytes left over\n",
s->stream_end - s->stream_ptr);
if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) {
av_log(s->avctx, AV_LOG_ERROR,
"decode finished with %d bytes left over\n",
bytestream2_get_bytes_left(&s->stream_ptr));
}
}
@ -1046,8 +971,8 @@ static int ipvideo_decode_frame(AVCodecContext *avctx,
return buf_size;
s->decoding_map = buf;
s->buf = buf + s->decoding_map_size;
s->size = buf_size - s->decoding_map_size;
bytestream2_init(&s->stream_ptr, buf + s->decoding_map_size,
buf_size - s->decoding_map_size);
s->current_frame.reference = 3;
if (avctx->get_buffer(avctx, &s->current_frame)) {

10
libavcodec/pthread.c
Unescape View File

@ -907,9 +907,13 @@ void ff_thread_flush(AVCodecContext *avctx)
fctx->next_decoding = fctx->next_finished = 0;
fctx->delaying = 1;
fctx->prev_thread = NULL;
// Make sure decode flush calls with size=0 won't return old frames
for (i = 0; i < avctx->thread_count; i++)
fctx->threads[i].got_frame = 0;
for (i = 0; i < avctx->thread_count; i++) {
PerThreadContext *p = &fctx->threads[i];
// Make sure decode flush calls with size=0 won't return old frames
p->got_frame = 0;
release_delayed_buffers(p);
}
}
static int *allocate_progress(PerThreadContext *p)

28
libavcodec/utvideo.c
Unescape View File

@ -358,13 +358,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
const uint8_t *buf_end = buf + buf_size;
UtvideoContext *c = avctx->priv_data;
const uint8_t *ptr;
int i, j;
const uint8_t *plane_start[5];
int plane_size, max_slice_size = 0, slice_start, slice_end, slice_size;
int ret;
GetByteContext gb;
if (c->pic.data[0])
ff_thread_release_buffer(avctx, &c->pic);
@ -377,20 +376,21 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
}
/* parse plane structure to retrieve frame flags and validate slice offsets */
ptr = buf;
bytestream2_init(&gb, buf, buf_size);
for (i = 0; i < c->planes; i++) {
plane_start[i] = ptr;
if (buf_end - ptr < 256 + 4 * c->slices) {
plane_start[i] = gb.buffer;
if (bytestream2_get_bytes_left(&gb) < 256 + 4 * c->slices) {
av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
return AVERROR_INVALIDDATA;
}
ptr += 256;
bytestream2_skipu(&gb, 256);
slice_start = 0;
slice_end = 0;
for (j = 0; j < c->slices; j++) {
slice_end = bytestream_get_le32(&ptr);
slice_end = bytestream2_get_le32u(&gb);
slice_size = slice_end - slice_start;
if (slice_size < 0) {
if (slice_end <= 0 || slice_size <= 0 ||
bytestream2_get_bytes_left(&gb) < slice_end) {
av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
return AVERROR_INVALIDDATA;
}
@ -398,18 +398,14 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
max_slice_size = FFMAX(max_slice_size, slice_size);
}
plane_size = slice_end;
if (buf_end - ptr < plane_size) {
av_log(avctx, AV_LOG_ERROR, "Plane size is bigger than available data\n");
return AVERROR_INVALIDDATA;
}
ptr += plane_size;
bytestream2_skipu(&gb, plane_size);
}
plane_start[c->planes] = ptr;
if (buf_end - ptr < c->frame_info_size) {
plane_start[c->planes] = gb.buffer;
if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
return AVERROR_INVALIDDATA;
}
c->frame_info = AV_RL32(ptr);
c->frame_info = bytestream2_get_le32u(&gb);
av_log(avctx, AV_LOG_DEBUG, "frame information flags %X\n", c->frame_info);
c->frame_pred = (c->frame_info >> 8) & 3;

2
libavcodec/x86/Makefile
Unescape View File

@ -25,6 +25,7 @@ YASM-OBJS-$(CONFIG_H264DSP) += x86/h264_deblock.o \
YASM-OBJS-$(CONFIG_H264PRED) += x86/h264_intrapred.o \
x86/h264_intrapred_10bit.o
MMX-OBJS-$(CONFIG_H264PRED) += x86/h264_intrapred_init.o
YASM-OBJS-$(CONFIG_H264QPEL) += x86/h264_qpel_10bit.o
MMX-OBJS-$(CONFIG_RV30_DECODER) += x86/rv34dsp_init.o
YASM-OBJS-$(CONFIG_RV30_DECODER) += x86/rv34dsp.o
@ -71,7 +72,6 @@ MMX-OBJS-$(CONFIG_VP8_DECODER) += x86/vp8dsp-init.o
MMX-OBJS-$(HAVE_YASM) += x86/dsputil_yasm.o \
x86/deinterlace.o \
x86/fmtconvert.o \
x86/h264_qpel_10bit.o \
$(YASM-OBJS-yes)
MMX-OBJS-$(CONFIG_FFT) += x86/fft.o

4281
libavcodec/x86/dsputil_mmx.c
View File

File diff suppressed because it is too large Load Diff

7
libavformat/movenc.c
Unescape View File

@ -2209,14 +2209,11 @@ static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov)
size);
av_free(ptr);
}
} else {
param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
track->enc->extradata_size);
}
if (track->enc->codec_id == CODEC_ID_H264) {
param_write_string(pb, "FourCC", "H264");
} else if (track->enc->codec_id == CODEC_ID_VC1) {
param_write_string(pb, "FourCC", "WVC1");
param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
track->enc->extradata_size);
}
param_write_int(pb, "MaxWidth", track->enc->width);
param_write_int(pb, "MaxHeight", track->enc->height);

Write Preview
Loading…
Cancel
Save