generic-library/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master:
  rtmpproto: Fix assignments in if()
  lavf: Fix assignments in if()
  svq1enc: Fix assignments in if()
  lavc: Fix assignments in if() when calling ff_af_queue_add
  h264: Fix assignments in if()
  truemotion2: cosmetics, reformat

Conflicts:
	libavcodec/svq1enc.c
	libavcodec/truemotion2.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2013-01-14 15:53:25 +01:00
commit 57d59e82cb
1 changed files with 152 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

276
libavcodec/truemotion2.c
View File

@ -31,14 +31,31 @@
#define TM2_ESCAPE 0x80000000 #define TM2_ESCAPE 0x80000000
#define TM2_DELTAS 64 #define TM2_DELTAS 64
/* Huffman-coded streams of different types of blocks */
enum TM2_STREAMS{ TM2_C_HI = 0, TM2_C_LO, TM2_L_HI, TM2_L_LO,
TM2_UPD, TM2_MOT, TM2_TYPE, TM2_NUM_STREAMS};
/* Block types */
enum TM2_BLOCKS{ TM2_HI_RES = 0, TM2_MED_RES, TM2_LOW_RES, TM2_NULL_RES,
TM2_UPDATE, TM2_STILL, TM2_MOTION};
typedef struct TM2Context{ /* Huffman-coded streams of different types of blocks */
enum TM2_STREAMS {
TM2_C_HI = 0,
TM2_C_LO,
TM2_L_HI,
TM2_L_LO,
TM2_UPD,
TM2_MOT,
TM2_TYPE,
TM2_NUM_STREAMS
};
/* Block types */
enum TM2_BLOCKS {
TM2_HI_RES = 0,
TM2_MED_RES,
TM2_LOW_RES,
TM2_NULL_RES,
TM2_UPDATE,
TM2_STILL,
TM2_MOTION
};
typedef struct TM2Context {
AVCodecContext *avctx; AVCodecContext *avctx;
AVFrame pic; AVFrame pic;
@ -69,7 +86,7 @@ typedef struct TM2Context{
/** /**
* Huffman codes for each of streams * Huffman codes for each of streams
*/ */
typedef struct TM2Codes{ typedef struct TM2Codes {
VLC vlc; ///< table for FFmpeg bitstream reader VLC vlc; ///< table for FFmpeg bitstream reader
int bits; int bits;
int *recode; ///< table for converting from code indexes to values int *recode; ///< table for converting from code indexes to values
@ -79,7 +96,7 @@ typedef struct TM2Codes{
/** /**
* structure for gathering Huffman codes information * structure for gathering Huffman codes information
*/ */
typedef struct TM2Huff{ typedef struct TM2Huff {
int val_bits; ///< length of literal int val_bits; ///< length of literal
int max_bits; ///< maximum length of code int max_bits; ///< maximum length of code
int min_bits; ///< minimum length of code int min_bits; ///< minimum length of code
@ -94,16 +111,17 @@ typedef struct TM2Huff{
static int tm2_read_tree(TM2Context *ctx, uint32_t prefix, int length, TM2Huff *huff) static int tm2_read_tree(TM2Context *ctx, uint32_t prefix, int length, TM2Huff *huff)
{ {
int ret; int ret;
if(length > huff->max_bits) { if (length > huff->max_bits) {
av_log(ctx->avctx, AV_LOG_ERROR, "Tree exceeded its given depth (%i)\n", huff->max_bits); av_log(ctx->avctx, AV_LOG_ERROR, "Tree exceeded its given depth (%i)\n",
huff->max_bits);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if(!get_bits1(&ctx->gb)) { /* literal */ if (!get_bits1(&ctx->gb)) { /* literal */
if (length == 0) { if (length == 0) {
length = 1; length = 1;
} }
if(huff->num >= huff->max_num) { if (huff->num >= huff->max_num) {
av_log(ctx->avctx, AV_LOG_DEBUG, "Too many literals\n"); av_log(ctx->avctx, AV_LOG_DEBUG, "Too many literals\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -129,29 +147,30 @@ static int tm2_build_huff_table(TM2Context *ctx, TM2Codes *code)
huff.val_bits = get_bits(&ctx->gb, 5); huff.val_bits = get_bits(&ctx->gb, 5);
huff.max_bits = get_bits(&ctx->gb, 5); huff.max_bits = get_bits(&ctx->gb, 5);
huff.min_bits = get_bits(&ctx->gb, 5); huff.min_bits = get_bits(&ctx->gb, 5);
huff.nodes = get_bits_long(&ctx->gb, 17); huff.nodes = get_bits_long(&ctx->gb, 17);
huff.num = 0; huff.num = 0;
/* check for correct codes parameters */ /* check for correct codes parameters */
if((huff.val_bits < 1) || (huff.val_bits > 32) || if ((huff.val_bits < 1) || (huff.val_bits > 32) ||
(huff.max_bits < 0) || (huff.max_bits > 25)) { (huff.max_bits < 0) || (huff.max_bits > 25)) {
av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect tree parameters - literal length: %i, max code length: %i\n", av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect tree parameters - literal "
huff.val_bits, huff.max_bits); "length: %i, max code length: %i\n", huff.val_bits, huff.max_bits);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
if((huff.nodes <= 0) || (huff.nodes > 0x10000)) { if ((huff.nodes <= 0) || (huff.nodes > 0x10000)) {
av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of Huffman tree nodes: %i\n", huff.nodes); av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of Huffman tree "
"nodes: %i\n", huff.nodes);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
/* one-node tree */ /* one-node tree */
if(huff.max_bits == 0) if (huff.max_bits == 0)
huff.max_bits = 1; huff.max_bits = 1;
/* allocate space for codes - it is exactly ceil(nodes / 2) entries */ /* allocate space for codes - it is exactly ceil(nodes / 2) entries */
huff.max_num = (huff.nodes + 1) >> 1; huff.max_num = (huff.nodes + 1) >> 1;
huff.nums = av_mallocz(huff.max_num * sizeof(int)); huff.nums = av_mallocz(huff.max_num * sizeof(int));
huff.bits = av_mallocz(huff.max_num * sizeof(uint32_t)); huff.bits = av_mallocz(huff.max_num * sizeof(uint32_t));
huff.lens = av_mallocz(huff.max_num * sizeof(int)); huff.lens = av_mallocz(huff.max_num * sizeof(int));
res = tm2_read_tree(ctx, 0, 0, &huff); res = tm2_read_tree(ctx, 0, 0, &huff);
@ -162,19 +181,19 @@ static int tm2_build_huff_table(TM2Context *ctx, TM2Codes *code)
} }
/* convert codes to vlc_table */ /* convert codes to vlc_table */
if(res >= 0) { if (res >= 0) {
int i; int i;
res = init_vlc(&code->vlc, huff.max_bits, huff.max_num, res = init_vlc(&code->vlc, huff.max_bits, huff.max_num,
huff.lens, sizeof(int), sizeof(int), huff.lens, sizeof(int), sizeof(int),
huff.bits, sizeof(uint32_t), sizeof(uint32_t), 0); huff.bits, sizeof(uint32_t), sizeof(uint32_t), 0);
if(res < 0) if (res < 0)
av_log(ctx->avctx, AV_LOG_ERROR, "Cannot build VLC table\n"); av_log(ctx->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
else { else {
code->bits = huff.max_bits; code->bits = huff.max_bits;
code->length = huff.max_num; code->length = huff.max_num;
code->recode = av_malloc(code->length * sizeof(int)); code->recode = av_malloc(code->length * sizeof(int));
for(i = 0; i < code->length; i++) for (i = 0; i < code->length; i++)
code->recode[i] = huff.nums[i]; code->recode[i] = huff.nums[i];
} }
} }
@ -189,7 +208,7 @@ static int tm2_build_huff_table(TM2Context *ctx, TM2Codes *code)
static void tm2_free_codes(TM2Codes *code) static void tm2_free_codes(TM2Codes *code)
{ {
av_free(code->recode); av_free(code->recode);
if(code->vlc.table) if (code->vlc.table)
ff_free_vlc(&code->vlc); ff_free_vlc(&code->vlc);
} }
@ -221,26 +240,27 @@ static inline int tm2_read_header(TM2Context *ctx, const uint8_t *buf)
} }
} }
static int tm2_read_deltas(TM2Context *ctx, int stream_id) { static int tm2_read_deltas(TM2Context *ctx, int stream_id)
{
int d, mb; int d, mb;
int i, v; int i, v;
d = get_bits(&ctx->gb, 9); d = get_bits(&ctx->gb, 9);
mb = get_bits(&ctx->gb, 5); mb = get_bits(&ctx->gb, 5);
if((d < 1) || (d > TM2_DELTAS) || (mb < 1) || (mb > 32)) { if ((d < 1) || (d > TM2_DELTAS) || (mb < 1) || (mb > 32)) {
av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect delta table: %i deltas x %i bits\n", d, mb); av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect delta table: %i deltas x %i bits\n", d, mb);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
for(i = 0; i < d; i++) { for (i = 0; i < d; i++) {
v = get_bits_long(&ctx->gb, mb); v = get_bits_long(&ctx->gb, mb);
if(v & (1 << (mb - 1))) if (v & (1 << (mb - 1)))
ctx->deltas[stream_id][i] = v - (1 << mb); ctx->deltas[stream_id][i] = v - (1 << mb);
else else
ctx->deltas[stream_id][i] = v; ctx->deltas[stream_id][i] = v;
} }
for(; i < TM2_DELTAS; i++) for (; i < TM2_DELTAS; i++)
ctx->deltas[stream_id][i] = 0; ctx->deltas[stream_id][i] = 0;
return 0; return 0;
@ -264,7 +284,7 @@ static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, i
len = bytestream2_get_be32(&gb); len = bytestream2_get_be32(&gb);
skip = len * 4 + 4; skip = len * 4 + 4;
if(len == 0) if (len == 0)
return 4; return 4;
if (len >= INT_MAX/4-1 || len < 0 || skip > buf_size) { if (len >= INT_MAX/4-1 || len < 0 || skip > buf_size) {
@ -273,12 +293,12 @@ static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, i
} }
toks = bytestream2_get_be32(&gb); toks = bytestream2_get_be32(&gb);
if(toks & 1) { if (toks & 1) {
len = bytestream2_get_be32(&gb); len = bytestream2_get_be32(&gb);
if(len == TM2_ESCAPE) { if (len == TM2_ESCAPE) {
len = bytestream2_get_be32(&gb); len = bytestream2_get_be32(&gb);
} }
if(len > 0) { if (len > 0) {
pos = bytestream2_tell(&gb); pos = bytestream2_tell(&gb);
if (skip <= pos) if (skip <= pos)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -290,7 +310,7 @@ static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, i
} }
/* skip unused fields */ /* skip unused fields */
len = bytestream2_get_be32(&gb); len = bytestream2_get_be32(&gb);
if(len == TM2_ESCAPE) { /* some unknown length - could be escaped too */ if (len == TM2_ESCAPE) { /* some unknown length - could be escaped too */
bytestream2_skip(&gb, 8); /* unused by decoder */ bytestream2_skip(&gb, 8); /* unused by decoder */
} else { } else {
bytestream2_skip(&gb, 4); /* unused by decoder */ bytestream2_skip(&gb, 4); /* unused by decoder */
@ -306,20 +326,20 @@ static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, i
toks >>= 1; toks >>= 1;
/* check if we have sane number of tokens */ /* check if we have sane number of tokens */
if((toks < 0) || (toks > 0xFFFFFF)){ if ((toks < 0) || (toks > 0xFFFFFF)) {
av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of tokens: %i\n", toks); av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of tokens: %i\n", toks);
tm2_free_codes(&codes); tm2_free_codes(&codes);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
ctx->tokens[stream_id] = av_realloc(ctx->tokens[stream_id], toks * sizeof(int)); ctx->tokens[stream_id] = av_realloc(ctx->tokens[stream_id], toks * sizeof(int));
ctx->tok_lens[stream_id] = toks; ctx->tok_lens[stream_id] = toks;
len = bytestream2_get_be32(&gb); len = bytestream2_get_be32(&gb);
if(len > 0) { if (len > 0) {
pos = bytestream2_tell(&gb); pos = bytestream2_tell(&gb);
if (skip <= pos) if (skip <= pos)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
init_get_bits(&ctx->gb, buf + pos, (skip - pos) * 8); init_get_bits(&ctx->gb, buf + pos, (skip - pos) * 8);
for(i = 0; i < toks; i++) { for (i = 0; i < toks; i++) {
if (get_bits_left(&ctx->gb) <= 0) { if (get_bits_left(&ctx->gb) <= 0) {
av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of tokens: %i\n", toks); av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of tokens: %i\n", toks);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -332,7 +352,7 @@ static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, i
} }
} }
} else { } else {
for(i = 0; i < toks; i++) { for (i = 0; i < toks; i++) {
ctx->tokens[stream_id][i] = codes.recode[0]; ctx->tokens[stream_id][i] = codes.recode[0];
if (stream_id <= TM2_MOT && ctx->tokens[stream_id][i] >= TM2_DELTAS) { if (stream_id <= TM2_MOT && ctx->tokens[stream_id][i] >= TM2_DELTAS) {
av_log(ctx->avctx, AV_LOG_ERROR, "Invalid delta token index %d for type %d, n=%d\n", av_log(ctx->avctx, AV_LOG_ERROR, "Invalid delta token index %d for type %d, n=%d\n",
@ -346,12 +366,13 @@ static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, i
return skip; return skip;
} }
static inline int GET_TOK(TM2Context *ctx,int type) { static inline int GET_TOK(TM2Context *ctx,int type)
if(ctx->tok_ptrs[type] >= ctx->tok_lens[type]) { {
if (ctx->tok_ptrs[type] >= ctx->tok_lens[type]) {
av_log(ctx->avctx, AV_LOG_ERROR, "Read token from stream %i out of bounds (%i>=%i)\n", type, ctx->tok_ptrs[type], ctx->tok_lens[type]); av_log(ctx->avctx, AV_LOG_ERROR, "Read token from stream %i out of bounds (%i>=%i)\n", type, ctx->tok_ptrs[type], ctx->tok_lens[type]);
return 0; return 0;
} }
if(type <= TM2_MOT) { if (type <= TM2_MOT) {
if (ctx->tokens[type][ctx->tok_ptrs[type]] >= TM2_DELTAS) { if (ctx->tokens[type][ctx->tok_ptrs[type]] >= TM2_DELTAS) {
av_log(ctx->avctx, AV_LOG_ERROR, "token %d is too large\n", ctx->tokens[type][ctx->tok_ptrs[type]]); av_log(ctx->avctx, AV_LOG_ERROR, "token %d is too large\n", ctx->tokens[type][ctx->tok_ptrs[type]]);
return 0; return 0;
@ -403,15 +424,15 @@ static inline void tm2_apply_deltas(TM2Context *ctx, int* Y, int stride, int *de
int ct, d; int ct, d;
int i, j; int i, j;
for(j = 0; j < 4; j++){ for (j = 0; j < 4; j++){
ct = ctx->D[j]; ct = ctx->D[j];
for(i = 0; i < 4; i++){ for (i = 0; i < 4; i++){
d = deltas[i + j * 4]; d = deltas[i + j * 4];
ct += d; ct += d;
last[i] += ct; last[i] += ct;
Y[i] = av_clip_uint8(last[i]); Y[i] = av_clip_uint8(last[i]);
} }
Y += stride; Y += stride;
ctx->D[j] = ct; ctx->D[j] = ct;
} }
} }
@ -419,11 +440,11 @@ static inline void tm2_apply_deltas(TM2Context *ctx, int* Y, int stride, int *de
static inline void tm2_high_chroma(int *data, int stride, int *last, int *CD, int *deltas) static inline void tm2_high_chroma(int *data, int stride, int *last, int *CD, int *deltas)
{ {
int i, j; int i, j;
for(j = 0; j < 2; j++){ for (j = 0; j < 2; j++) {
for(i = 0; i < 2; i++){ for (i = 0; i < 2; i++) {
CD[j] += deltas[i + j * 2]; CD[j] += deltas[i + j * 2];
last[i] += CD[j]; last[i] += CD[j];
data[i] = last[i]; data[i] = last[i];
} }
data += stride; data += stride;
} }
@ -435,14 +456,14 @@ static inline void tm2_low_chroma(int *data, int stride, int *clast, int *CD, in
int l; int l;
int prev; int prev;
if(bx > 0) if (bx > 0)
prev = clast[-3]; prev = clast[-3];
else else
prev = 0; prev = 0;
t = (CD[0] + CD[1]) >> 1; t = (CD[0] + CD[1]) >> 1;
l = (prev - CD[0] - CD[1] + clast[1]) >> 1; l = (prev - CD[0] - CD[1] + clast[1]) >> 1;
CD[1] = CD[0] + CD[1] - t; CD[1] = CD[0] + CD[1] - t;
CD[0] = t; CD[0] = t;
clast[0] = l; clast[0] = l;
tm2_high_chroma(data, stride, clast, CD, deltas); tm2_high_chroma(data, stride, clast, CD, deltas);
@ -455,15 +476,15 @@ static inline void tm2_hi_res_block(TM2Context *ctx, AVFrame *pic, int bx, int b
TM2_INIT_POINTERS(); TM2_INIT_POINTERS();
/* hi-res chroma */ /* hi-res chroma */
for(i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
deltas[i] = GET_TOK(ctx, TM2_C_HI); deltas[i] = GET_TOK(ctx, TM2_C_HI);
deltas[i + 4] = GET_TOK(ctx, TM2_C_HI); deltas[i + 4] = GET_TOK(ctx, TM2_C_HI);
} }
tm2_high_chroma(U, Ustride, clast, ctx->CD, deltas); tm2_high_chroma(U, Ustride, clast, ctx->CD, deltas);
tm2_high_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas + 4); tm2_high_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas + 4);
/* hi-res luma */ /* hi-res luma */
for(i = 0; i < 16; i++) for (i = 0; i < 16; i++)
deltas[i] = GET_TOK(ctx, TM2_L_HI); deltas[i] = GET_TOK(ctx, TM2_L_HI);
tm2_apply_deltas(ctx, Y, Ystride, deltas, last); tm2_apply_deltas(ctx, Y, Ystride, deltas, last);
@ -485,7 +506,7 @@ static inline void tm2_med_res_block(TM2Context *ctx, AVFrame *pic, int bx, int
tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx); tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx);
/* hi-res luma */ /* hi-res luma */
for(i = 0; i < 16; i++) for (i = 0; i < 16; i++)
deltas[i] = GET_TOK(ctx, TM2_L_HI); deltas[i] = GET_TOK(ctx, TM2_L_HI);
tm2_apply_deltas(ctx, Y, Ystride, deltas, last); tm2_apply_deltas(ctx, Y, Ystride, deltas, last);
@ -508,7 +529,7 @@ static inline void tm2_low_res_block(TM2Context *ctx, AVFrame *pic, int bx, int
tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx); tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx);
/* low-res luma */ /* low-res luma */
for(i = 0; i < 16; i++) for (i = 0; i < 16; i++)
deltas[i] = 0; deltas[i] = 0;
deltas[ 0] = GET_TOK(ctx, TM2_L_LO); deltas[ 0] = GET_TOK(ctx, TM2_L_LO);
@ -516,7 +537,7 @@ static inline void tm2_low_res_block(TM2Context *ctx, AVFrame *pic, int bx, int
deltas[ 8] = GET_TOK(ctx, TM2_L_LO); deltas[ 8] = GET_TOK(ctx, TM2_L_LO);
deltas[10] = GET_TOK(ctx, TM2_L_LO); deltas[10] = GET_TOK(ctx, TM2_L_LO);
if(bx > 0) if (bx > 0)
last[0] = (last[-1] - ctx->D[0] - ctx->D[1] - ctx->D[2] - ctx->D[3] + last[1]) >> 1; last[0] = (last[-1] - ctx->D[0] - ctx->D[1] - ctx->D[2] - ctx->D[3] + last[1]) >> 1;
else else
last[0] = (last[1] - ctx->D[0] - ctx->D[1] - ctx->D[2] - ctx->D[3])>> 1; last[0] = (last[1] - ctx->D[0] - ctx->D[1] - ctx->D[2] - ctx->D[3])>> 1;
@ -548,18 +569,18 @@ static inline void tm2_null_res_block(TM2Context *ctx, AVFrame *pic, int bx, int
tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx); tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx);
/* null luma */ /* null luma */
for(i = 0; i < 16; i++) for (i = 0; i < 16; i++)
deltas[i] = 0; deltas[i] = 0;
ct = ctx->D[0] + ctx->D[1] + ctx->D[2] + ctx->D[3]; ct = ctx->D[0] + ctx->D[1] + ctx->D[2] + ctx->D[3];
if(bx > 0) if (bx > 0)
left = last[-1] - ct; left = last[-1] - ct;
else else
left = 0; left = 0;
right = last[3]; right = last[3];
diff = right - left; diff = right - left;
last[0] = left + (diff >> 2); last[0] = left + (diff >> 2);
last[1] = left + (diff >> 1); last[1] = left + (diff >> 1);
last[2] = right - (diff >> 2); last[2] = right - (diff >> 2);
@ -568,11 +589,11 @@ static inline void tm2_null_res_block(TM2Context *ctx, AVFrame *pic, int bx, int
int tp = left; int tp = left;
ctx->D[0] = (tp + (ct >> 2)) - left; ctx->D[0] = (tp + (ct >> 2)) - left;
left += ctx->D[0]; left += ctx->D[0];
ctx->D[1] = (tp + (ct >> 1)) - left; ctx->D[1] = (tp + (ct >> 1)) - left;
left += ctx->D[1]; left += ctx->D[1];
ctx->D[2] = ((tp + ct) - (ct >> 2)) - left; ctx->D[2] = ((tp + ct) - (ct >> 2)) - left;
left += ctx->D[2]; left += ctx->D[2];
ctx->D[3] = (tp + ct) - left; ctx->D[3] = (tp + ct) - left;
} }
tm2_apply_deltas(ctx, Y, Ystride, deltas, last); tm2_apply_deltas(ctx, Y, Ystride, deltas, last);
@ -584,12 +605,12 @@ static inline void tm2_still_block(TM2Context *ctx, AVFrame *pic, int bx, int by
TM2_INIT_POINTERS_2(); TM2_INIT_POINTERS_2();
/* update chroma */ /* update chroma */
for(j = 0; j < 2; j++){ for (j = 0; j < 2; j++) {
for(i = 0; i < 2; i++){ for (i = 0; i < 2; i++){
U[i] = Uo[i]; U[i] = Uo[i];
V[i] = Vo[i]; V[i] = Vo[i];
} }
U += Ustride; V += Vstride; U += Ustride; V += Vstride;
Uo += oUstride; Vo += oVstride; Uo += oUstride; Vo += oVstride;
} }
U -= Ustride * 2; U -= Ustride * 2;
@ -603,12 +624,12 @@ static inline void tm2_still_block(TM2Context *ctx, AVFrame *pic, int bx, int by
ctx->D[2] = Yo[3 + oYstride * 2] - Yo[3 + oYstride]; ctx->D[2] = Yo[3 + oYstride * 2] - Yo[3 + oYstride];
ctx->D[3] = Yo[3 + oYstride * 3] - Yo[3 + oYstride * 2]; ctx->D[3] = Yo[3 + oYstride * 3] - Yo[3 + oYstride * 2];
for(j = 0; j < 4; j++){ for (j = 0; j < 4; j++) {
for(i = 0; i < 4; i++){ for (i = 0; i < 4; i++) {
Y[i] = Yo[i]; Y[i] = Yo[i];
last[i] = Yo[i]; last[i] = Yo[i];
} }
Y += Ystride; Y += Ystride;
Yo += oYstride; Yo += oYstride;
} }
} }
@ -620,13 +641,15 @@ static inline void tm2_update_block(TM2Context *ctx, AVFrame *pic, int bx, int b
TM2_INIT_POINTERS_2(); TM2_INIT_POINTERS_2();
/* update chroma */ /* update chroma */
for(j = 0; j < 2; j++){ for (j = 0; j < 2; j++) {
for(i = 0; i < 2; i++){ for (i = 0; i < 2; i++) {
U[i] = Uo[i] + GET_TOK(ctx, TM2_UPD); U[i] = Uo[i] + GET_TOK(ctx, TM2_UPD);
V[i] = Vo[i] + GET_TOK(ctx, TM2_UPD); V[i] = Vo[i] + GET_TOK(ctx, TM2_UPD);
} }
U += Ustride; V += Vstride; U += Ustride;
Uo += oUstride; Vo += oVstride; V += Vstride;
Uo += oUstride;
Vo += oVstride;
} }
U -= Ustride * 2; U -= Ustride * 2;
V -= Vstride * 2; V -= Vstride * 2;
@ -639,14 +662,14 @@ static inline void tm2_update_block(TM2Context *ctx, AVFrame *pic, int bx, int b
ctx->D[2] = Yo[3 + oYstride * 2] - Yo[3 + oYstride]; ctx->D[2] = Yo[3 + oYstride * 2] - Yo[3 + oYstride];
ctx->D[3] = Yo[3 + oYstride * 3] - Yo[3 + oYstride * 2]; ctx->D[3] = Yo[3 + oYstride * 3] - Yo[3 + oYstride * 2];
for(j = 0; j < 4; j++){ for (j = 0; j < 4; j++) {
d = last[3]; d = last[3];
for(i = 0; i < 4; i++){ for (i = 0; i < 4; i++) {
Y[i] = Yo[i] + GET_TOK(ctx, TM2_UPD); Y[i] = Yo[i] + GET_TOK(ctx, TM2_UPD);
last[i] = Y[i]; last[i] = Y[i];
} }
ctx->D[j] = last[3] - d; ctx->D[j] = last[3] - d;
Y += Ystride; Y += Ystride;
Yo += oYstride; Yo += oYstride;
} }
} }
@ -672,13 +695,15 @@ static inline void tm2_motion_block(TM2Context *ctx, AVFrame *pic, int bx, int b
Vo += (my >> 1) * oVstride + (mx >> 1); Vo += (my >> 1) * oVstride + (mx >> 1);
/* copy chroma */ /* copy chroma */
for(j = 0; j < 2; j++){ for (j = 0; j < 2; j++) {
for(i = 0; i < 2; i++){ for (i = 0; i < 2; i++) {
U[i] = Uo[i]; U[i] = Uo[i];
V[i] = Vo[i]; V[i] = Vo[i];
} }
U += Ustride; V += Vstride; U += Ustride;
Uo += oUstride; Vo += oVstride; V += Vstride;
Uo += oUstride;
Vo += oVstride;
} }
U -= Ustride * 2; U -= Ustride * 2;
V -= Vstride * 2; V -= Vstride * 2;
@ -686,11 +711,11 @@ static inline void tm2_motion_block(TM2Context *ctx, AVFrame *pic, int bx, int b
TM2_RECALC_BLOCK(V, Vstride, (clast + 2), (ctx->CD + 2)); TM2_RECALC_BLOCK(V, Vstride, (clast + 2), (ctx->CD + 2));
/* copy luma */ /* copy luma */
for(j = 0; j < 4; j++){ for (j = 0; j < 4; j++) {
for(i = 0; i < 4; i++){ for (i = 0; i < 4; i++) {
Y[i] = Yo[i]; Y[i] = Yo[i];
} }
Y += Ystride; Y += Ystride;
Yo += oYstride; Yo += oYstride;
} }
/* calculate deltas */ /* calculate deltas */
@ -699,7 +724,7 @@ static inline void tm2_motion_block(TM2Context *ctx, AVFrame *pic, int bx, int b
ctx->D[1] = Y[3 + Ystride] - Y[3]; ctx->D[1] = Y[3 + Ystride] - Y[3];
ctx->D[2] = Y[3 + Ystride * 2] - Y[3 + Ystride]; ctx->D[2] = Y[3 + Ystride * 2] - Y[3 + Ystride];
ctx->D[3] = Y[3 + Ystride * 3] - Y[3 + Ystride * 2]; ctx->D[3] = Y[3 + Ystride * 3] - Y[3 + Ystride * 2];
for(i = 0; i < 4; i++) for (i = 0; i < 4; i++)
last[i] = Y[i + Ystride * 3]; last[i] = Y[i + Ystride * 3];
} }
@ -712,10 +737,10 @@ static int tm2_decode_blocks(TM2Context *ctx, AVFrame *p)
int *Y, *U, *V; int *Y, *U, *V;
uint8_t *dst; uint8_t *dst;
for(i = 0; i < TM2_NUM_STREAMS; i++) for (i = 0; i < TM2_NUM_STREAMS; i++)
ctx->tok_ptrs[i] = 0; ctx->tok_ptrs[i] = 0;
if (ctx->tok_lens[TM2_TYPE]<bw*bh){ if (ctx->tok_lens[TM2_TYPE]<bw*bh) {
av_log(ctx->avctx,AV_LOG_ERROR,"Got %i tokens for %i blocks\n",ctx->tok_lens[TM2_TYPE],bw*bh); av_log(ctx->avctx,AV_LOG_ERROR,"Got %i tokens for %i blocks\n",ctx->tok_lens[TM2_TYPE],bw*bh);
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
@ -723,10 +748,10 @@ static int tm2_decode_blocks(TM2Context *ctx, AVFrame *p)
memset(ctx->last, 0, 4 * bw * sizeof(int)); memset(ctx->last, 0, 4 * bw * sizeof(int));
memset(ctx->clast, 0, 4 * bw * sizeof(int)); memset(ctx->clast, 0, 4 * bw * sizeof(int));
for(j = 0; j < bh; j++) { for (j = 0; j < bh; j++) {
memset(ctx->D, 0, 4 * sizeof(int)); memset(ctx->D, 0, 4 * sizeof(int));
memset(ctx->CD, 0, 4 * sizeof(int)); memset(ctx->CD, 0, 4 * sizeof(int));
for(i = 0; i < bw; i++) { for (i = 0; i < bw; i++) {
type = GET_TOK(ctx, TM2_TYPE); type = GET_TOK(ctx, TM2_TYPE);
switch(type) { switch(type) {
case TM2_HI_RES: case TM2_HI_RES:
@ -764,8 +789,8 @@ static int tm2_decode_blocks(TM2Context *ctx, AVFrame *p)
U = (ctx->cur?ctx->U2:ctx->U1); U = (ctx->cur?ctx->U2:ctx->U1);
V = (ctx->cur?ctx->V2:ctx->V1); V = (ctx->cur?ctx->V2:ctx->V1);
dst = p->data[0]; dst = p->data[0];
for(j = 0; j < h; j++){ for (j = 0; j < h; j++) {
for(i = 0; i < w; i++){ for (i = 0; i < w; i++) {
int y = Y[i], u = U[i >> 1], v = V[i >> 1]; int y = Y[i], u = U[i >> 1], v = V[i >> 1];
dst[3*i+0] = av_clip_uint8(y + v); dst[3*i+0] = av_clip_uint8(y + v);
dst[3*i+1] = av_clip_uint8(y); dst[3*i+1] = av_clip_uint8(y);
@ -829,14 +854,15 @@ static int decode_frame(AVCodecContext *avctx,
void *data, int *got_frame, void *data, int *got_frame,
AVPacket *avpkt) AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size & ~3;
TM2Context * const l = avctx->priv_data; TM2Context * const l = avctx->priv_data;
AVFrame * const p = &l->pic; const uint8_t *buf = avpkt->data;
int i, offset = TM2_HEADER_SIZE, t, ret; int buf_size = avpkt->size & ~3;
AVFrame * const p = &l->pic;
int offset = TM2_HEADER_SIZE;
int i, t, ret;
av_fast_padded_malloc(&l->buffer, &l->buffer_size, buf_size); av_fast_padded_malloc(&l->buffer, &l->buffer_size, buf_size);
if(!l->buffer){ if (!l->buffer) {
av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer\n"); av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer\n");
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
@ -853,7 +879,7 @@ static int decode_frame(AVCodecContext *avctx,
return ret; return ret;
} }
for(i = 0; i < TM2_NUM_STREAMS; i++){ for (i = 0; i < TM2_NUM_STREAMS; i++) {
if (offset >= buf_size) { if (offset >= buf_size) {
av_log(avctx, AV_LOG_ERROR, "no space for tm2_read_stream\n"); av_log(avctx, AV_LOG_ERROR, "no space for tm2_read_stream\n");
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -861,13 +887,13 @@ static int decode_frame(AVCodecContext *avctx,
t = tm2_read_stream(l, l->buffer + offset, tm2_stream_order[i], t = tm2_read_stream(l, l->buffer + offset, tm2_stream_order[i],
buf_size - offset); buf_size - offset);
if(t < 0){ if (t < 0) {
return t; return t;
} }
offset += t; offset += t;
} }
p->key_frame = tm2_decode_blocks(l, p); p->key_frame = tm2_decode_blocks(l, p);
if(p->key_frame) if (p->key_frame)
p->pict_type = AV_PICTURE_TYPE_I; p->pict_type = AV_PICTURE_TYPE_I;
else else
p->pict_type = AV_PICTURE_TYPE_P; p->pict_type = AV_PICTURE_TYPE_P;
@ -879,17 +905,18 @@ static int decode_frame(AVCodecContext *avctx,
return buf_size; return buf_size;
} }
static av_cold int decode_init(AVCodecContext *avctx){ static av_cold int decode_init(AVCodecContext *avctx)
{
TM2Context * const l = avctx->priv_data; TM2Context * const l = avctx->priv_data;
int i, w = avctx->width, h = avctx->height; int i, w = avctx->width, h = avctx->height;
if((avctx->width & 3) || (avctx->height & 3)){ if ((avctx->width & 3) || (avctx->height & 3)) {
av_log(avctx, AV_LOG_ERROR, "Width and height must be multiple of 4\n"); av_log(avctx, AV_LOG_ERROR, "Width and height must be multiple of 4\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
l->avctx = avctx; l->avctx = avctx;
l->pic.data[0]=NULL; l->pic.data[0] = NULL;
avctx->pix_fmt = AV_PIX_FMT_BGR24; avctx->pix_fmt = AV_PIX_FMT_BGR24;
avcodec_get_frame_defaults(&l->pic); avcodec_get_frame_defaults(&l->pic);
@ -898,7 +925,7 @@ static av_cold int decode_init(AVCodecContext *avctx){
l->last = av_malloc(4 * sizeof(*l->last) * (w >> 2)); l->last = av_malloc(4 * sizeof(*l->last) * (w >> 2));
l->clast = av_malloc(4 * sizeof(*l->clast) * (w >> 2)); l->clast = av_malloc(4 * sizeof(*l->clast) * (w >> 2));
for(i = 0; i < TM2_NUM_STREAMS; i++) { for (i = 0; i < TM2_NUM_STREAMS; i++) {
l->tokens[i] = NULL; l->tokens[i] = NULL;
l->tok_lens[i] = 0; l->tok_lens[i] = 0;
} }
@ -939,16 +966,17 @@ static av_cold int decode_init(AVCodecContext *avctx){
return 0; return 0;
} }
static av_cold int decode_end(AVCodecContext *avctx){ static av_cold int decode_end(AVCodecContext *avctx)
{
TM2Context * const l = avctx->priv_data; TM2Context * const l = avctx->priv_data;
AVFrame *pic = &l->pic; AVFrame *pic = &l->pic;
int i; int i;
av_free(l->last); av_free(l->last);
av_free(l->clast); av_free(l->clast);
for(i = 0; i < TM2_NUM_STREAMS; i++) for (i = 0; i < TM2_NUM_STREAMS; i++)
av_free(l->tokens[i]); av_free(l->tokens[i]);
if(l->Y1){ if (l->Y1) {
av_free(l->Y1_base); av_free(l->Y1_base);
av_free(l->U1_base); av_free(l->U1_base);
av_free(l->V1_base); av_free(l->V1_base);