Merge commit 'bb675d3ac6d722d5e117ae9042a996b55ca05b1d'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 15 Dec 2012 12:41:06 +0000 (13:41 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 15 Dec 2012 12:41:06 +0000 (13:41 +0100)
* commit 'bb675d3ac6d722d5e117ae9042a996b55ca05b1d':
  vp56: make parse_header return standard error codes

Conflicts:
libavcodec/vp56.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/vp5.c
libavcodec/vp56.c
libavcodec/vp56.h
libavcodec/vp6.c

Simple merge
@@@ -523,169 -505,158 +523,169 @@@ int ff_vp56_decode_frame(AVCodecContex
              return -1;
      }
  
 -    for (is_alpha=0; is_alpha < 1+s->has_alpha; is_alpha++) {
 -        int mb_row, mb_col, mb_row_flip, mb_offset = 0;
 -        int block, y, uv, stride_y, stride_uv;
 -        int golden_frame = 0;
 -        int res;
 +    res = s->parse_header(s, buf, remaining_buf_size);
-     if (!res)
-         return -1;
++    if (res < 0)
++        return res;
  
-     if (res == 2) {
 -        s->modelp = &s->models[is_alpha];
++    if (res == VP56_SIZE_CHANGE) {
 +        for (i = 0; i < 4; i++) {
 +            if (s->frames[i].data[0])
 +                avctx->release_buffer(avctx, &s->frames[i]);
 +        }
 +    }
  
 -        res = s->parse_header(s, buf, remaining_buf_size, &golden_frame);
 -        if (res < 0)
 -            return res;
 +    p->reference = 3;
 +    if (ff_get_buffer(avctx, p) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return -1;
 +    }
  
-     if (res == 2) {
 -        if (res == VP56_SIZE_CHANGE) {
 -            int i;
 -            for (i = 0; i < 4; i++) {
 -                if (s->frames[i].data[0])
 -                    avctx->release_buffer(avctx, &s->frames[i]);
 -            }
 -            if (is_alpha) {
 -                avcodec_set_dimensions(avctx, 0, 0);
 -                return -1;
 -            }
++    if (res == VP56_SIZE_CHANGE) {
 +        if (vp56_size_changed(s)) {
 +            avctx->release_buffer(avctx, p);
 +            return -1;
          }
 +    }
  
 -        if (!is_alpha) {
 -            p->reference = 1;
 -            if (ff_get_buffer(avctx, p) < 0) {
 -                av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 -                return -1;
 +    if (s->has_alpha) {
 +        int bak_w = avctx->width;
 +        int bak_h = avctx->height;
 +        int bak_cw = avctx->coded_width;
 +        int bak_ch = avctx->coded_height;
 +        buf += alpha_offset;
 +        remaining_buf_size -= alpha_offset;
 +
 +        res = s->alpha_context->parse_header(s->alpha_context, buf, remaining_buf_size);
-         if (res != 1) {
-             if(res==2) {
++        if (res != 0) {
++            if(res==VP56_SIZE_CHANGE) {
 +                av_log(avctx, AV_LOG_ERROR, "Alpha reconfiguration\n");
 +                avctx->width  = bak_w;
 +                avctx->height = bak_h;
 +                avctx->coded_width  = bak_cw;
 +                avctx->coded_height = bak_ch;
              }
 -
 -            if (res == VP56_SIZE_CHANGE)
 -                if (vp56_size_changed(avctx)) {
 -                    avctx->release_buffer(avctx, p);
 -                    return -1;
 -                }
 +            avctx->release_buffer(avctx, p);
 +            return -1;
          }
 +    }
  
 -        if (p->key_frame) {
 -            p->pict_type = AV_PICTURE_TYPE_I;
 -            s->default_models_init(s);
 -            for (block=0; block<s->mb_height*s->mb_width; block++)
 -                s->macroblocks[block].type = VP56_MB_INTRA;
 -        } else {
 -            p->pict_type = AV_PICTURE_TYPE_P;
 -            vp56_parse_mb_type_models(s);
 -            s->parse_vector_models(s);
 -            s->mb_type = VP56_MB_INTER_NOVEC_PF;
 -        }
 +    avctx->execute2(avctx, ff_vp56_decode_mbs, 0, 0, s->has_alpha + 1);
  
 -        if (s->parse_coeff_models(s))
 -            goto next;
 +    /* release frames that aren't in use */
 +    for (i = 0; i < 4; ++i) {
 +        AVFrame *victim = &s->frames[i];
 +        if (!victim->data[0])
 +            continue;
 +        if (victim != s->framep[VP56_FRAME_PREVIOUS] &&
 +            victim != s->framep[VP56_FRAME_GOLDEN] &&
 +            (!s->has_alpha || victim != s->alpha_context->framep[VP56_FRAME_GOLDEN]))
 +            avctx->release_buffer(avctx, victim);
 +    }
 +
 +    p->qstride = 0;
 +    p->qscale_table = s->qscale_table;
 +    p->qscale_type = FF_QSCALE_TYPE_VP56;
 +    *(AVFrame*)data = *p;
 +    *got_frame = 1;
  
 -        memset(s->prev_dc, 0, sizeof(s->prev_dc));
 -        s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
 -        s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
 +    return avpkt->size;
 +}
  
 -        for (block=0; block < 4*s->mb_width+6; block++) {
 -            s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
 -            s->above_blocks[block].dc_coeff = 0;
 -            s->above_blocks[block].not_null_dc = 0;
 -        }
 -        s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
 -        s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
 +static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *data,
 +                              int jobnr, int threadnr)
 +{
 +    VP56Context *s0 = avctx->priv_data;
 +    int is_alpha = (jobnr == 1);
 +    VP56Context *s = is_alpha ? s0->alpha_context : s0;
 +    AVFrame *const p = s->framep[VP56_FRAME_CURRENT];
 +    int mb_row, mb_col, mb_row_flip, mb_offset = 0;
 +    int block, y, uv, stride_y, stride_uv;
 +
 +    if (p->key_frame) {
 +        p->pict_type = AV_PICTURE_TYPE_I;
 +        s->default_models_init(s);
 +        for (block=0; block<s->mb_height*s->mb_width; block++)
 +            s->macroblocks[block].type = VP56_MB_INTRA;
 +    } else {
 +        p->pict_type = AV_PICTURE_TYPE_P;
 +        vp56_parse_mb_type_models(s);
 +        s->parse_vector_models(s);
 +        s->mb_type = VP56_MB_INTER_NOVEC_PF;
 +    }
  
 -        stride_y  = p->linesize[0];
 -        stride_uv = p->linesize[1];
 +    if (s->parse_coeff_models(s))
 +        goto next;
  
 +    memset(s->prev_dc, 0, sizeof(s->prev_dc));
 +    s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
 +    s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
 +
 +    for (block=0; block < 4*s->mb_width+6; block++) {
 +        s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
 +        s->above_blocks[block].dc_coeff = 0;
 +        s->above_blocks[block].not_null_dc = 0;
 +    }
 +    s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
 +    s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
 +
 +    stride_y  = p->linesize[0];
 +    stride_uv = p->linesize[1];
 +
 +    if (s->flip < 0)
 +        mb_offset = 7;
 +
 +    /* main macroblocks loop */
 +    for (mb_row=0; mb_row<s->mb_height; mb_row++) {
          if (s->flip < 0)
 -            mb_offset = 7;
 -
 -        /* main macroblocks loop */
 -        for (mb_row=0; mb_row<s->mb_height; mb_row++) {
 -            if (s->flip < 0)
 -                mb_row_flip = s->mb_height - mb_row - 1;
 -            else
 -                mb_row_flip = mb_row;
 -
 -            for (block=0; block<4; block++) {
 -                s->left_block[block].ref_frame = VP56_FRAME_NONE;
 -                s->left_block[block].dc_coeff = 0;
 -                s->left_block[block].not_null_dc = 0;
 -            }
 -            memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
 -            memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
 -
 -            s->above_block_idx[0] = 1;
 -            s->above_block_idx[1] = 2;
 -            s->above_block_idx[2] = 1;
 -            s->above_block_idx[3] = 2;
 -            s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
 -            s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
 -
 -            s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
 -            s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
 -            s->block_offset[1] = s->block_offset[0] + 8;
 -            s->block_offset[3] = s->block_offset[2] + 8;
 -            s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
 -            s->block_offset[5] = s->block_offset[4];
 -
 -            for (mb_col=0; mb_col<s->mb_width; mb_col++) {
 -                vp56_decode_mb(s, mb_row, mb_col, is_alpha);
 -
 -                for (y=0; y<4; y++) {
 -                    s->above_block_idx[y] += 2;
 -                    s->block_offset[y] += 16;
 -                }
 +            mb_row_flip = s->mb_height - mb_row - 1;
 +        else
 +            mb_row_flip = mb_row;
  
 -                for (uv=4; uv<6; uv++) {
 -                    s->above_block_idx[uv] += 1;
 -                    s->block_offset[uv] += 8;
 -                }
 -            }
 +        for (block=0; block<4; block++) {
 +            s->left_block[block].ref_frame = VP56_FRAME_NONE;
 +            s->left_block[block].dc_coeff = 0;
 +            s->left_block[block].not_null_dc = 0;
          }
 +        memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
 +        memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
 +
 +        s->above_block_idx[0] = 1;
 +        s->above_block_idx[1] = 2;
 +        s->above_block_idx[2] = 1;
 +        s->above_block_idx[3] = 2;
 +        s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
 +        s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
 +
 +        s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
 +        s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
 +        s->block_offset[1] = s->block_offset[0] + 8;
 +        s->block_offset[3] = s->block_offset[2] + 8;
 +        s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
 +        s->block_offset[5] = s->block_offset[4];
 +
 +        for (mb_col=0; mb_col<s->mb_width; mb_col++) {
 +            vp56_decode_mb(s, mb_row, mb_col, is_alpha);
 +
 +            for (y=0; y<4; y++) {
 +                s->above_block_idx[y] += 2;
 +                s->block_offset[y] += 16;
 +            }
  
 -    next:
 -        if (p->key_frame || golden_frame) {
 -            if (s->framep[VP56_FRAME_GOLDEN]->data[0] &&
 -                s->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2])
 -                avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN]);
 -            s->framep[VP56_FRAME_GOLDEN] = p;
 +            for (uv=4; uv<6; uv++) {
 +                s->above_block_idx[uv] += 1;
 +                s->block_offset[uv] += 8;
 +            }
          }
 +    }
  
 -        if (s->has_alpha) {
 -            FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],
 -                              s->framep[VP56_FRAME_GOLDEN2]);
 -            buf += alpha_offset;
 -            remaining_buf_size -= alpha_offset;
 -        }
 +next:
 +    if (p->key_frame || s->golden_frame) {
 +        s->framep[VP56_FRAME_GOLDEN] = p;
      }
  
 -    if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] ||
 -        s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) {
 -        if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] &&
 -            s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2])
 -            FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
 -                              s->framep[VP56_FRAME_UNUSED]);
 -        else
 -            FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS],
 -                              s->framep[VP56_FRAME_UNUSED2]);
 -    } else if (s->framep[VP56_FRAME_PREVIOUS]->data[0])
 -        avctx->release_buffer(avctx, s->framep[VP56_FRAME_PREVIOUS]);
      FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT],
                        s->framep[VP56_FRAME_PREVIOUS]);
 -
 -    p->qstride = 0;
 -    p->qscale_table = s->qscale_table;
 -    p->qscale_type = FF_QSCALE_TYPE_VP56;
 -    *(AVFrame*)data = *p;
 -    *got_frame = 1;
 -
 -    return avpkt->size;
 +    return 0;
  }
  
  av_cold void ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
Simple merge
@@@ -99,10 -100,9 +99,10 @@@ static int vp6_parse_header(VP56Contex
          if (sub_version < 8)
              vrt_shift = 5;
          s->sub_version = sub_version;
 +        s->golden_frame = 0;
      } else {
          if (!s->sub_version || !s->avctx->coded_width || !s->avctx->coded_height)
-             return 0;
+             return AVERROR_INVALIDDATA;
  
          if (separated_coeff || !s->filter_header) {
              coeff_offset = AV_RB16(buf+1) - 2;