* @author Michael Niedermayer <michaelni@gmx.at>
*/
+#include "libavutil/avassert.h"
#include "libavutil/imgutils.h"
#include "internal.h"
#include "cabac.h"
#include "rectangle.h"
#include "svq3.h"
#include "thread.h"
-#include "vdpau_internal.h"
-#include "libavutil/avassert.h"
-// #undef NDEBUG
#include <assert.h>
const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
};
+static const uint8_t field_scan[16] = {
+ 0 + 0 * 4, 0 + 1 * 4, 1 + 0 * 4, 0 + 2 * 4,
+ 0 + 3 * 4, 1 + 1 * 4, 1 + 2 * 4, 1 + 3 * 4,
+ 2 + 0 * 4, 2 + 1 * 4, 2 + 2 * 4, 2 + 3 * 4,
+ 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4,
+};
+
+static const uint8_t field_scan8x8[64] = {
+ 0 + 0 * 8, 0 + 1 * 8, 0 + 2 * 8, 1 + 0 * 8,
+ 1 + 1 * 8, 0 + 3 * 8, 0 + 4 * 8, 1 + 2 * 8,
+ 2 + 0 * 8, 1 + 3 * 8, 0 + 5 * 8, 0 + 6 * 8,
+ 0 + 7 * 8, 1 + 4 * 8, 2 + 1 * 8, 3 + 0 * 8,
+ 2 + 2 * 8, 1 + 5 * 8, 1 + 6 * 8, 1 + 7 * 8,
+ 2 + 3 * 8, 3 + 1 * 8, 4 + 0 * 8, 3 + 2 * 8,
+ 2 + 4 * 8, 2 + 5 * 8, 2 + 6 * 8, 2 + 7 * 8,
+ 3 + 3 * 8, 4 + 1 * 8, 5 + 0 * 8, 4 + 2 * 8,
+ 3 + 4 * 8, 3 + 5 * 8, 3 + 6 * 8, 3 + 7 * 8,
+ 4 + 3 * 8, 5 + 1 * 8, 6 + 0 * 8, 5 + 2 * 8,
+ 4 + 4 * 8, 4 + 5 * 8, 4 + 6 * 8, 4 + 7 * 8,
+ 5 + 3 * 8, 6 + 1 * 8, 6 + 2 * 8, 5 + 4 * 8,
+ 5 + 5 * 8, 5 + 6 * 8, 5 + 7 * 8, 6 + 3 * 8,
+ 7 + 0 * 8, 7 + 1 * 8, 6 + 4 * 8, 6 + 5 * 8,
+ 6 + 6 * 8, 6 + 7 * 8, 7 + 2 * 8, 7 + 3 * 8,
+ 7 + 4 * 8, 7 + 5 * 8, 7 + 6 * 8, 7 + 7 * 8,
+};
+
+static const uint8_t field_scan8x8_cavlc[64] = {
+ 0 + 0 * 8, 1 + 1 * 8, 2 + 0 * 8, 0 + 7 * 8,
+ 2 + 2 * 8, 2 + 3 * 8, 2 + 4 * 8, 3 + 3 * 8,
+ 3 + 4 * 8, 4 + 3 * 8, 4 + 4 * 8, 5 + 3 * 8,
+ 5 + 5 * 8, 7 + 0 * 8, 6 + 6 * 8, 7 + 4 * 8,
+ 0 + 1 * 8, 0 + 3 * 8, 1 + 3 * 8, 1 + 4 * 8,
+ 1 + 5 * 8, 3 + 1 * 8, 2 + 5 * 8, 4 + 1 * 8,
+ 3 + 5 * 8, 5 + 1 * 8, 4 + 5 * 8, 6 + 1 * 8,
+ 5 + 6 * 8, 7 + 1 * 8, 6 + 7 * 8, 7 + 5 * 8,
+ 0 + 2 * 8, 0 + 4 * 8, 0 + 5 * 8, 2 + 1 * 8,
+ 1 + 6 * 8, 4 + 0 * 8, 2 + 6 * 8, 5 + 0 * 8,
+ 3 + 6 * 8, 6 + 0 * 8, 4 + 6 * 8, 6 + 2 * 8,
+ 5 + 7 * 8, 6 + 4 * 8, 7 + 2 * 8, 7 + 6 * 8,
+ 1 + 0 * 8, 1 + 2 * 8, 0 + 6 * 8, 3 + 0 * 8,
+ 1 + 7 * 8, 3 + 2 * 8, 2 + 7 * 8, 4 + 2 * 8,
+ 3 + 7 * 8, 5 + 2 * 8, 4 + 7 * 8, 5 + 4 * 8,
+ 6 + 3 * 8, 6 + 5 * 8, 7 + 3 * 8, 7 + 7 * 8,
+};
+
+// zigzag_scan8x8_cavlc[i] = zigzag_scan8x8[(i/4) + 16*(i%4)]
+static const uint8_t zigzag_scan8x8_cavlc[64] = {
+ 0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
+ 4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
+ 3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
+ 2 + 7 * 8, 6 + 4 * 8, 5 + 6 * 8, 7 + 5 * 8,
+ 1 + 0 * 8, 2 + 0 * 8, 0 + 3 * 8, 3 + 1 * 8,
+ 3 + 2 * 8, 0 + 6 * 8, 4 + 2 * 8, 6 + 1 * 8,
+ 2 + 5 * 8, 2 + 6 * 8, 6 + 2 * 8, 5 + 4 * 8,
+ 3 + 7 * 8, 7 + 3 * 8, 4 + 7 * 8, 7 + 6 * 8,
+ 0 + 1 * 8, 3 + 0 * 8, 0 + 4 * 8, 4 + 0 * 8,
+ 2 + 3 * 8, 1 + 5 * 8, 5 + 1 * 8, 5 + 2 * 8,
+ 1 + 6 * 8, 3 + 5 * 8, 7 + 1 * 8, 4 + 5 * 8,
+ 4 + 6 * 8, 7 + 4 * 8, 5 + 7 * 8, 6 + 7 * 8,
+ 0 + 2 * 8, 2 + 1 * 8, 1 + 3 * 8, 5 + 0 * 8,
+ 1 + 4 * 8, 2 + 4 * 8, 6 + 0 * 8, 4 + 3 * 8,
+ 0 + 7 * 8, 4 + 4 * 8, 7 + 2 * 8, 3 + 6 * 8,
+ 5 + 5 * 8, 6 + 5 * 8, 6 + 6 * 8, 7 + 7 * 8,
+};
+
+static const uint8_t dequant4_coeff_init[6][3] = {
+ { 10, 13, 16 },
+ { 11, 14, 18 },
+ { 13, 16, 20 },
+ { 14, 18, 23 },
+ { 16, 20, 25 },
+ { 18, 23, 29 },
+};
+
+static const uint8_t dequant8_coeff_init_scan[16] = {
+ 0, 3, 4, 3, 3, 1, 5, 1, 4, 5, 2, 5, 3, 1, 5, 1
+};
+
+static const uint8_t dequant8_coeff_init[6][6] = {
+ { 20, 18, 32, 19, 25, 24 },
+ { 22, 19, 35, 21, 28, 26 },
+ { 26, 23, 42, 24, 33, 31 },
+ { 28, 25, 45, 26, 35, 33 },
+ { 32, 28, 51, 30, 40, 38 },
+ { 36, 32, 58, 34, 46, 43 },
+};
+
static const enum AVPixelFormat h264_hwaccel_pixfmt_list_420[] = {
#if CONFIG_H264_DXVA2_HWACCEL
AV_PIX_FMT_DXVA2_VLD,
int (*mv)[2][4][2],
int mb_x, int mb_y, int mb_intra, int mb_skipped)
{
- H264Context *h = opaque;
+ H264Context *h = opaque;
h->mb_x = mb_x;
h->mb_y = mb_y;
const int field_pic = h->picture_structure != PICT_FRAME;
if (field_pic) {
height <<= 1;
- y <<= 1;
+ y <<= 1;
}
height = FFMIN(height, avctx->height - y);
int i;
if (cur->f.pict_type == AV_PICTURE_TYPE_B || h->low_delay ||
- (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
+ (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
src = &cur->f;
else if (last)
src = &last->f;
if (ret < 0)
goto fail;
-
dst->qscale_table_buf = av_buffer_ref(src->qscale_table_buf);
dst->mb_type_buf = av_buffer_ref(src->mb_type_buf);
if (!dst->qscale_table_buf || !dst->mb_type_buf)
dst->qscale_table = src->qscale_table;
dst->mb_type = src->mb_type;
- for (i = 0; i < 2; i ++) {
+ for (i = 0; i < 2; i++) {
dst->motion_val_buf[i] = av_buffer_ref(src->motion_val_buf[i]);
dst->ref_index_buf[i] = av_buffer_ref(src->ref_index_buf[i]);
if (!dst->motion_val_buf[i] || !dst->ref_index_buf[i])
memcpy(dst->ref_poc, src->ref_poc, sizeof(src->ref_poc));
memcpy(dst->ref_count, src->ref_count, sizeof(src->ref_count));
- dst->poc = src->poc;
- dst->frame_num = src->frame_num;
- dst->mmco_reset = src->mmco_reset;
- dst->pic_id = src->pic_id;
- dst->long_ref = src->long_ref;
- dst->mbaff = src->mbaff;
- dst->field_picture = src->field_picture;
- dst->needs_realloc = src->needs_realloc;
- dst->reference = src->reference;
+ dst->poc = src->poc;
+ dst->frame_num = src->frame_num;
+ dst->mmco_reset = src->mmco_reset;
+ dst->pic_id = src->pic_id;
+ dst->long_ref = src->long_ref;
+ dst->mbaff = src->mbaff;
+ dst->field_picture = src->field_picture;
+ dst->needs_realloc = src->needs_realloc;
+ dst->reference = src->reference;
return 0;
fail:
return ret;
}
-
static int alloc_scratch_buffers(H264Context *h, int linesize)
{
int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
av_log(h->avctx, AV_LOG_ERROR,
"top block unavailable for requested intra4x4 mode %d at %d %d\n",
status, h->mb_x, h->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
} else if (status) {
h->intra4x4_pred_mode_cache[scan8[0] + i] = status;
}
av_log(h->avctx, AV_LOG_ERROR,
"left block unavailable for requested intra4x4 mode %d at %d %d\n",
status, h->mb_x, h->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
} else if (status) {
h->intra4x4_pred_mode_cache[scan8[0] + 8 * i] = status;
}
av_log(h->avctx, AV_LOG_ERROR,
"out of range intra chroma pred mode at %d %d\n",
h->mb_x, h->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (!(h->top_samples_available & 0x8000)) {
av_log(h->avctx, AV_LOG_ERROR,
"top block unavailable for requested intra mode at %d %d\n",
h->mb_x, h->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
av_log(h->avctx, AV_LOG_ERROR,
"left block unavailable for requested intra mode at %d %d\n",
h->mb_x, h->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
length--;
#define STARTCODE_TEST \
- if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
- if (src[i + 2] != 3) { \
- /* startcode, so we must be past the end */ \
- length = i; \
- } \
- break; \
- }
+ if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
+ if (src[i + 2] != 3) { \
+ /* startcode, so we must be past the end */ \
+ length = i; \
+ } \
+ break; \
+ }
+
#if HAVE_FAST_UNALIGNED
#define FIND_FIRST_ZERO \
- if (i > 0 && !src[i]) \
- i--; \
- while (src[i]) \
- i++
+ if (i > 0 && !src[i]) \
+ i--; \
+ while (src[i]) \
+ i++
+
#if HAVE_FAST_64BIT
for (i = 0; i + 1 < length; i += 9) {
if (!((~AV_RN64A(src + i) &
}
while (si < length)
dst[di++] = src[si++];
-nsc:
+nsc:
memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
*dst_length = di;
static inline int get_lowest_part_list_y(H264Context *h, Picture *pic, int n,
int height, int y_offset, int list)
{
- int raw_my = h->mv_cache[list][scan8[n]][1];
+ int raw_my = h->mv_cache[list][scan8[n]][1];
int filter_height_up = (raw_my & 3) ? 2 : 0;
int filter_height_down = (raw_my & 3) ? 3 : 0;
- int full_my = (raw_my >> 2) + y_offset;
- int top = full_my - filter_height_up;
- int bottom = full_my + filter_height_down + height;
+ int full_my = (raw_my >> 2) + y_offset;
+ int top = full_my - filter_height_up;
+ int bottom = full_my + filter_height_down + height;
return FFMAX(abs(top), bottom);
}
// Error resilience puts the current picture in the ref list.
// Don't try to wait on these as it will cause a deadlock.
// Fields can wait on each other, though.
- if (ref->tf.progress->data != h->cur_pic.tf.progress->data ||
+ if (ref->tf.progress->data != h->cur_pic.tf.progress->data ||
(ref->reference & 3) != h->picture_structure) {
my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);
if (refs[0][ref_n] < 0)
int ff_h264_alloc_tables(H264Context *h)
{
- const int big_mb_num = h->mb_stride * (h->mb_height + 1);
- const int row_mb_num = h->mb_stride * 2 * h->avctx->thread_count;
+ const int big_mb_num = h->mb_stride * (h->mb_height + 1);
+ const int row_mb_num = h->mb_stride * 2 * h->avctx->thread_count;
int x, y, i;
FF_ALLOCZ_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
fail:
free_tables(h, 1);
- return -1;
+ return AVERROR(ENOMEM);
}
/**
er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride;
er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
- h->mb_stride + h->mb_width;
+ h->mb_stride + h->mb_width;
FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
mb_array_size * sizeof(uint8_t), fail);
return 0;
fail:
- return -1; // free_tables will clean up for us
+ return AVERROR(ENOMEM); // free_tables will clean up for us
}
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size,
int ff_h264_decode_extradata(H264Context *h)
{
AVCodecContext *avctx = h->avctx;
+ int ret;
if (avctx->extradata[0] == 1) {
int i, cnt, nalsize;
if (avctx->extradata_size < 7) {
av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
/* sps and pps in the avcC always have length coded with 2 bytes,
* so put a fake nal_length_size = 2 while parsing them */
for (i = 0; i < cnt; i++) {
nalsize = AV_RB16(p) + 2;
if (p - avctx->extradata + nalsize > avctx->extradata_size)
- return -1;
- if (decode_nal_units(h, p, nalsize, 1) < 0) {
+ return AVERROR_INVALIDDATA;
+ ret = decode_nal_units(h, p, nalsize, 1);
+ if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
"Decoding sps %d from avcC failed\n", i);
- return -1;
+ return ret;
}
p += nalsize;
}
for (i = 0; i < cnt; i++) {
nalsize = AV_RB16(p) + 2;
if (p - avctx->extradata + nalsize > avctx->extradata_size)
- return -1;
- if (decode_nal_units(h, p, nalsize, 1) < 0) {
+ return AVERROR_INVALIDDATA;
+ ret = decode_nal_units(h, p, nalsize, 1);
+ if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
"Decoding pps %d from avcC failed\n", i);
- return -1;
+ return ret;
}
p += nalsize;
}
h->nal_length_size = (avctx->extradata[4] & 0x03) + 1;
} else {
h->is_avc = 0;
- if (decode_nal_units(h, avctx->extradata, avctx->extradata_size, 1) < 0)
- return -1;
+ ret = decode_nal_units(h, avctx->extradata, avctx->extradata_size, 1);
+ if (ret < 0)
+ return ret;
}
return 0;
}
{
H264Context *h = avctx->priv_data;
int i;
+ int ret;
h->avctx = avctx;
ff_h264_decode_init_vlc();
- h->pixel_shift = 0;
+ h->pixel_shift = 0;
h->sps.bit_depth_luma = avctx->bits_per_raw_sample = 8;
h->thread_context[0] = h;
avctx->ticks_per_frame = 2;
}
- if (avctx->extradata_size > 0 && avctx->extradata &&
- ff_h264_decode_extradata(h))
- return -1;
+ if (avctx->extradata_size > 0 && avctx->extradata) {
+ ret = ff_h264_decode_extradata(h);
+ if (ret < 0)
+ return ret;
+ }
if (h->sps.bitstream_restriction_flag &&
h->avctx->has_b_frames < h->sps.num_reorder_frames) {
#undef REBASE_PICTURE
#define REBASE_PICTURE(pic, new_ctx, old_ctx) \
((pic && pic >= old_ctx->DPB && \
- pic < old_ctx->DPB + MAX_PICTURE_COUNT) ? \
- &new_ctx->DPB[pic - old_ctx->DPB] : NULL)
+ pic < old_ctx->DPB + MAX_PICTURE_COUNT) ? \
+ &new_ctx->DPB[pic - old_ctx->DPB] : NULL)
static void copy_picture_range(Picture **to, Picture **from, int count,
H264Context *new_base,
return 0;
if (inited &&
- (h->width != h1->width ||
- h->height != h1->height ||
- h->mb_width != h1->mb_width ||
- h->mb_height != h1->mb_height ||
+ (h->width != h1->width ||
+ h->height != h1->height ||
+ h->mb_width != h1->mb_width ||
+ h->mb_height != h1->mb_height ||
h->sps.bit_depth_luma != h1->sps.bit_depth_luma ||
h->sps.chroma_format_idc != h1->sps.chroma_format_idc ||
h->sps.colorspace != h1->sps.colorspace)) {
avcodec_get_frame_defaults(&h->cur_pic.f);
h->cur_pic.tf.f = &h->cur_pic.f;
- h->avctx = dst;
- h->DPB = NULL;
+ h->avctx = dst;
+ h->DPB = NULL;
h->qscale_table_pool = NULL;
- h->mb_type_pool = NULL;
- h->ref_index_pool = NULL;
- h->motion_val_pool = NULL;
+ h->mb_type_pool = NULL;
+ h->ref_index_pool = NULL;
+ h->motion_val_pool = NULL;
- if (ff_h264_alloc_tables(h) < 0) {
+ ret = ff_h264_alloc_tables(h);
+ if (ret < 0) {
av_log(dst, AV_LOG_ERROR, "Could not allocate memory for h264\n");
- return AVERROR(ENOMEM);
+ return ret;
+ }
+ ret = context_init(h);
+ if (ret < 0) {
+ av_log(dst, AV_LOG_ERROR, "context_init() failed.\n");
+ return ret;
}
- context_init(h);
for (i = 0; i < 2; i++) {
h->rbsp_buffer[i] = NULL;
return ret;
}
- h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);
+ h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);
unref_picture(h, &h->cur_pic);
if ((ret = ref_picture(h, &h->cur_pic, &h1->cur_pic)) < 0)
return ret;
}
pic = &h->DPB[i];
- pic->reference = h->droppable ? 0 : h->picture_structure;
+ pic->reference = h->droppable ? 0 : h->picture_structure;
pic->f.coded_picture_number = h->coded_picture_number++;
pic->field_picture = h->picture_structure != PICT_FRAME;
/*
int i, pics, out_of_order, out_idx;
int invalid = 0, cnt = 0;
- h->cur_pic_ptr->f.pict_type = h->pict_type;
+ h->cur_pic_ptr->f.pict_type = h->pict_type;
if (h->next_output_pic)
return;
if (IS_INTRA4x4(mb_type)) {
if (IS_8x8DCT(mb_type)) {
if (transform_bypass) {
- idct_dc_add =
- idct_add = h->h264dsp.h264_add_pixels8_clear;
+ idct_dc_add =
+ idct_add = h->h264dsp.h264_add_pixels8_clear;
} else {
idct_dc_add = h->h264dsp.h264_idct8_dc_add;
idct_add = h->h264dsp.h264_idct8_add;
0 * 16, 1 * 16, 4 * 16, 5 * 16,
2 * 16, 3 * 16, 6 * 16, 7 * 16,
8 * 16, 9 * 16, 12 * 16, 13 * 16,
- 10 * 16, 11 * 16, 14 * 16, 15 * 16 };
+ 10 * 16, 11 * 16, 14 * 16, 15 * 16
+ };
for (i = 0; i < 16; i++)
dctcoef_set(h->mb + (p * 256 << pixel_shift),
pixel_shift, dc_mapping[i],
{
const int mb_xy = h->mb_xy;
const int mb_type = h->cur_pic.mb_type[mb_xy];
- int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || h->qscale == 0;
+ int is_complex = CONFIG_SMALL || h->is_complex ||
+ IS_INTRA_PCM(mb_type) || h->qscale == 0;
if (CHROMA444(h)) {
if (is_complex || h->pixel_shift)
h->chroma_weight[i][list][j][1] = get_se_golomb(&h->gb);
if (h->chroma_weight[i][list][j][0] != chroma_def ||
h->chroma_weight[i][list][j][1] != 0) {
- h->use_weight_chroma = 1;
+ h->use_weight_chroma = 1;
h->chroma_weight_flag[list] = 1;
}
}
}
if (h->ref_count[0] == 1 && h->ref_count[1] == 1 && !FRAME_MBAFF(h) &&
h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2 * cur_poc) {
- h->use_weight = 0;
+ h->use_weight = 0;
h->use_weight_chroma = 0;
return;
}
int i;
for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
h->last_pocs[i] = INT_MIN;
- h->outputed_poc = h->next_outputed_poc = INT_MIN;
+ h->outputed_poc = h->next_outputed_poc = INT_MIN;
h->prev_interlaced_frame = 1;
idr(h);
if (h->cur_pic_ptr)
h->parse_context.last_index = 0;
}
-static int init_poc(H264Context *h)
+int ff_init_poc(H264Context *h, int pic_field_poc[2], int *pic_poc)
{
const int max_frame_num = 1 << h->sps.log2_max_frame_num;
int field_poc[2];
- Picture *cur = h->cur_pic_ptr;
h->frame_num_offset = h->prev_frame_num_offset;
if (h->frame_num < h->prev_frame_num)
if (h->sps.poc_type == 0) {
const int max_poc_lsb = 1 << h->sps.log2_max_poc_lsb;
- if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb / 2)
+ if (h->poc_lsb < h->prev_poc_lsb &&
+ h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb / 2)
h->poc_msb = h->prev_poc_msb + max_poc_lsb;
- else if (h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb / 2)
+ else if (h->poc_lsb > h->prev_poc_lsb &&
+ h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb / 2)
h->poc_msb = h->prev_poc_msb - max_poc_lsb;
else
h->poc_msb = h->prev_poc_msb;
}
if (h->picture_structure != PICT_BOTTOM_FIELD)
- h->cur_pic_ptr->field_poc[0] = field_poc[0];
+ pic_field_poc[0] = field_poc[0];
if (h->picture_structure != PICT_TOP_FIELD)
- h->cur_pic_ptr->field_poc[1] = field_poc[1];
- cur->poc = FFMIN(cur->field_poc[0], cur->field_poc[1]);
+ pic_field_poc[1] = field_poc[1];
+ *pic_poc = FFMIN(pic_field_poc[0], pic_field_poc[1]);
return 0;
}
ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
h->picture_structure == PICT_BOTTOM_FIELD);
- if (CONFIG_H264_VDPAU_DECODER &&
- h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
- ff_vdpau_h264_set_reference_frames(h);
-
if (in_setup || !(avctx->active_thread_type & FF_THREAD_FRAME)) {
if (!h->droppable) {
err = ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
"hardware accelerator failed to decode picture\n");
}
- if (CONFIG_H264_VDPAU_DECODER &&
- h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
- ff_vdpau_h264_picture_complete(h);
-
/*
* FIXME: Error handling code does not seem to support interlaced
* when slices span multiple rows
if (h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
h->cur_chroma_format_idc != h->sps.chroma_format_idc) {
- if (h->avctx->codec &&
- h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU &&
- (h->sps.bit_depth_luma != 8 || h->sps.chroma_format_idc > 1)) {
- av_log(h->avctx, AV_LOG_ERROR,
- "VDPAU decoding does not support video colorspace.\n");
- return AVERROR_INVALIDDATA;
- }
if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {
h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
h->cur_chroma_format_idc = h->sps.chroma_format_idc;
av_log(h->avctx, AV_LOG_WARNING, "Ignoring cropping information.\n");
h->sps.crop_bottom = h->sps.crop_top = h->sps.crop_right = h->sps.crop_left = 0;
- h->sps.crop = 0;
+ h->sps.crop = 0;
width = h->width;
height = h->height;
int nb_slices = (HAVE_THREADS &&
h->avctx->active_thread_type & FF_THREAD_SLICE) ?
h->avctx->thread_count : 1;
- int i;
+ int i, ret;
h->avctx->sample_aspect_ratio = h->sps.sar;
av_assert0(h->avctx->sample_aspect_ratio.den);
if (reinit)
free_tables(h, 0);
- h->first_field = 0;
+ h->first_field = 0;
h->prev_interlaced_frame = 1;
init_scan_tables(h);
- if (ff_h264_alloc_tables(h) < 0) {
+ ret = ff_h264_alloc_tables(h);
+ if (ret < 0) {
av_log(h->avctx, AV_LOG_ERROR,
"Could not allocate memory for h264\n");
- return AVERROR(ENOMEM);
+ return ret;
}
if (nb_slices > MAX_THREADS || (nb_slices > h->mb_height && h->mb_height)) {
h->slice_context_count = nb_slices;
if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_SLICE)) {
- if (context_init(h) < 0) {
+ ret = context_init(h);
+ if (ret < 0) {
av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
- return -1;
+ return ret;
}
} else {
for (i = 1; i < h->slice_context_count; i++) {
H264Context *c;
- c = h->thread_context[i] = av_mallocz(sizeof(H264Context));
- c->avctx = h->avctx;
- c->dsp = h->dsp;
- c->vdsp = h->vdsp;
- c->h264dsp = h->h264dsp;
- c->h264qpel = h->h264qpel;
- c->h264chroma = h->h264chroma;
- c->sps = h->sps;
- c->pps = h->pps;
- c->pixel_shift = h->pixel_shift;
- c->width = h->width;
- c->height = h->height;
- c->linesize = h->linesize;
- c->uvlinesize = h->uvlinesize;
- c->chroma_x_shift = h->chroma_x_shift;
- c->chroma_y_shift = h->chroma_y_shift;
- c->qscale = h->qscale;
- c->droppable = h->droppable;
+ c = h->thread_context[i] = av_mallocz(sizeof(H264Context));
+ c->avctx = h->avctx;
+ c->dsp = h->dsp;
+ c->vdsp = h->vdsp;
+ c->h264dsp = h->h264dsp;
+ c->h264qpel = h->h264qpel;
+ c->h264chroma = h->h264chroma;
+ c->sps = h->sps;
+ c->pps = h->pps;
+ c->pixel_shift = h->pixel_shift;
+ c->width = h->width;
+ c->height = h->height;
+ c->linesize = h->linesize;
+ c->uvlinesize = h->uvlinesize;
+ c->chroma_x_shift = h->chroma_x_shift;
+ c->chroma_y_shift = h->chroma_y_shift;
+ c->qscale = h->qscale;
+ c->droppable = h->droppable;
c->data_partitioning = h->data_partitioning;
- c->low_delay = h->low_delay;
- c->mb_width = h->mb_width;
- c->mb_height = h->mb_height;
- c->mb_stride = h->mb_stride;
- c->mb_num = h->mb_num;
- c->flags = h->flags;
- c->workaround_bugs = h->workaround_bugs;
- c->pict_type = h->pict_type;
+ c->low_delay = h->low_delay;
+ c->mb_width = h->mb_width;
+ c->mb_height = h->mb_height;
+ c->mb_stride = h->mb_stride;
+ c->mb_num = h->mb_num;
+ c->flags = h->flags;
+ c->workaround_bugs = h->workaround_bugs;
+ c->pict_type = h->pict_type;
init_scan_tables(c);
clone_tables(c, h, i);
}
for (i = 0; i < h->slice_context_count; i++)
- if (context_init(h->thread_context[i]) < 0) {
+ if ((ret = context_init(h->thread_context[i])) < 0) {
av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
- return -1;
+ return ret;
}
}
int default_ref_list_done = 0;
int last_pic_structure, last_pic_droppable;
int needs_reinit = 0;
+ int field_pic_flag, bottom_field_flag;
h->me.qpel_put = h->h264qpel.put_h264_qpel_pixels_tab;
h->me.qpel_avg = h->h264qpel.avg_h264_qpel_pixels_tab;
av_log(h->avctx, AV_LOG_ERROR,
"slice type too large (%d) at %d %d\n",
h->slice_type, h->mb_x, h->mb_y);
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (slice_type > 4) {
slice_type -= 5;
pps_id = get_ue_golomb(&h->gb);
if (pps_id >= MAX_PPS_COUNT) {
av_log(h->avctx, AV_LOG_ERROR, "pps_id out of range\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (!h0->pps_buffers[pps_id]) {
av_log(h->avctx, AV_LOG_ERROR,
"non-existing PPS %u referenced\n",
pps_id);
- return -1;
+ return AVERROR_INVALIDDATA;
}
h->pps = *h0->pps_buffers[pps_id];
av_log(h->avctx, AV_LOG_ERROR,
"non-existing SPS %u referenced\n",
h->pps.sps_id);
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (h->pps.sps_id != h->current_sps_id ||
(h->width != h->avctx->coded_width ||
h->height != h->avctx->coded_height ||
needs_reinit)) {
-
if (h != h0) {
av_log(h->avctx, AV_LOG_ERROR, "changing width/height on "
"slice %d\n", h0->current_slice + 1);
if (h != h0) {
av_log(h->avctx, AV_LOG_ERROR,
"Cannot (re-)initialize context during parallel decoding.\n");
- return -1;
+ return AVERROR_PATCHWELCOME;
}
if ((ret = get_pixel_format(h)) < 0)
if (h->sps.frame_mbs_only_flag) {
h->picture_structure = PICT_FRAME;
} else {
- if (get_bits1(&h->gb)) { // field_pic_flag
- h->picture_structure = PICT_TOP_FIELD + get_bits1(&h->gb); // bottom_field_flag
+ field_pic_flag = get_bits1(&h->gb);
+ if (field_pic_flag) {
+ bottom_field_flag = get_bits1(&h->gb);
+ h->picture_structure = PICT_TOP_FIELD + bottom_field_flag;
} else {
h->picture_structure = PICT_FRAME;
h->mb_aff_frame = h->sps.mb_aff;
Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
h->frame_num, h->prev_frame_num);
- if (h264_frame_start(h) < 0)
- return -1;
+ ret = h264_frame_start(h);
+ if (ret < 0)
+ return ret;
h->prev_frame_num++;
- h->prev_frame_num %= 1 << h->sps.log2_max_frame_num;
+ h->prev_frame_num %= 1 << h->sps.log2_max_frame_num;
h->cur_pic_ptr->frame_num = h->prev_frame_num;
ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
- if ((ret = ff_generate_sliding_window_mmcos(h, 1)) < 0 &&
- h->avctx->err_recognition & AV_EF_EXPLODE)
+ ret = ff_generate_sliding_window_mmcos(h, 1);
+ if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
return ret;
- if (ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index) < 0 &&
- (h->avctx->err_recognition & AV_EF_EXPLODE))
- return AVERROR_INVALIDDATA;
- /* Error concealment: if a ref is missing, copy the previous ref in its place.
- * FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions
- * about there being no actual duplicates.
- * FIXME: this doesn't copy padding for out-of-frame motion vectors. Given we're
- * concealing a lost frame, this probably isn't noticeable by comparison, but it should
- * be fixed. */
+ ret = ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
+ if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+ return ret;
+ /* Error concealment: If a ref is missing, copy the previous ref
+ * in its place.
+ * FIXME: Avoiding a memcpy would be nice, but ref handling makes
+ * many assumptions about there being no actual duplicates.
+ * FIXME: This does not copy padding for out-of-frame motion
+ * vectors. Given we are concealing a lost frame, this probably
+ * is not noticeable by comparison, but it should be fixed. */
if (h->short_ref_count) {
if (prev) {
- av_image_copy(h->short_ref[0]->f.data, h->short_ref[0]->f.linesize,
- (const uint8_t **)prev->f.data, prev->f.linesize,
- h->avctx->pix_fmt, h->mb_width * 16, h->mb_height * 16);
+ av_image_copy(h->short_ref[0]->f.data,
+ h->short_ref[0]->f.linesize,
+ (const uint8_t **)prev->f.data,
+ prev->f.linesize,
+ h->avctx->pix_fmt,
+ h->mb_width * 16,
+ h->mb_height * 16);
h->short_ref[0]->poc = prev->poc + 2;
}
h->short_ref[0]->frame_num = h->prev_frame_num;
if (!FIELD_PICTURE(h) || h0->first_field) {
if (h264_frame_start(h) < 0) {
h0->first_field = 0;
- return -1;
+ return AVERROR_INVALIDDATA;
}
} else {
release_unused_pictures(h, 0);
if (first_mb_in_slice << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
first_mb_in_slice >= h->mb_num) {
av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
h->resync_mb_x = h->mb_x = first_mb_in_slice % h->mb_width;
- h->resync_mb_y = h->mb_y = (first_mb_in_slice / h->mb_width) << FIELD_OR_MBAFF_PICTURE(h);
+ h->resync_mb_y = h->mb_y = (first_mb_in_slice / h->mb_width) <<
+ FIELD_OR_MBAFF_PICTURE(h);
if (h->picture_structure == PICT_BOTTOM_FIELD)
h->resync_mb_y = h->mb_y = h->mb_y + 1;
assert(h->mb_y < h->mb_height);
h->delta_poc[1] = get_se_golomb(&h->gb);
}
- init_poc(h);
+ ff_init_poc(h, h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc);
if (h->pps.redundant_pic_cnt_present)
h->redundant_pic_count = get_ue_golomb(&h->gb);
else
h->list_count = 1;
} else {
- h->list_count = 0;
+ h->list_count = 0;
h->ref_count[0] = h->ref_count[1] = 0;
}
-
max_refs = h->picture_structure == PICT_FRAME ? 16 : 32;
if (h->ref_count[0] > max_refs || h->ref_count[1] > max_refs) {
if (!default_ref_list_done)
ff_h264_fill_default_ref_list(h);
- if (h->slice_type_nos != AV_PICTURE_TYPE_I &&
- ff_h264_decode_ref_pic_list_reordering(h) < 0) {
- h->ref_count[1] = h->ref_count[0] = 0;
- return -1;
+ if (h->slice_type_nos != AV_PICTURE_TYPE_I) {
+ ret = ff_h264_decode_ref_pic_list_reordering(h);
+ if (ret < 0) {
+ h->ref_count[1] = h->ref_count[0] = 0;
+ return ret;
+ }
}
if ((h->pps.weighted_pred && h->slice_type_nos == AV_PICTURE_TYPE_P) ||
// or h->mmco, which will cause ref list mix-ups and decoding errors
// further down the line. This may break decoding if the first slice is
// corrupt, thus we only do this if frame-mt is enabled.
- if (h->nal_ref_idc &&
- ff_h264_decode_ref_pic_marking(h0, &h->gb,
- !(h->avctx->active_thread_type & FF_THREAD_FRAME) ||
- h0->current_slice == 0) < 0 &&
- (h->avctx->err_recognition & AV_EF_EXPLODE))
- return AVERROR_INVALIDDATA;
+ if (h->nal_ref_idc) {
+ ret = ff_h264_decode_ref_pic_marking(h0, &h->gb,
+ !(h->avctx->active_thread_type & FF_THREAD_FRAME) ||
+ h0->current_slice == 0);
+ if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+ return AVERROR_INVALIDDATA;
+ }
if (FRAME_MBAFF(h)) {
ff_h264_fill_mbaff_ref_list(h);
tmp = get_ue_golomb_31(&h->gb);
if (tmp > 2) {
av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
h->cabac_init_idc = tmp;
}
tmp = h->pps.init_qp + get_se_golomb(&h->gb);
if (tmp > 51 + 6 * (h->sps.bit_depth_luma - 8)) {
av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
- return -1;
+ return AVERROR_INVALIDDATA;
}
h->qscale = tmp;
h->chroma_qp[0] = get_chroma_qp(h, 0, h->qscale);
if (tmp > 2) {
av_log(h->avctx, AV_LOG_ERROR,
"deblocking_filter_idc %u out of range\n", tmp);
- return -1;
+ return AVERROR_INVALIDDATA;
}
h->deblocking_filter = tmp;
if (h->deblocking_filter < 2)
av_log(h->avctx, AV_LOG_ERROR,
"deblocking filter parameters %d %d out of range\n",
h->slice_alpha_c0_offset, h->slice_beta_offset);
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
}
6 * (h->sps.bit_depth_luma - 8);
h0->last_slice_type = slice_type;
- h->slice_num = ++h0->current_slice;
+ h->slice_num = ++h0->current_slice;
if (h->slice_num >= MAX_SLICES) {
av_log(h->avctx, AV_LOG_ERROR,
"Too many slices, increase MAX_SLICES and recompile\n");
int *ref2frm = h->ref2frm[h->slice_num & (MAX_SLICES - 1)][j];
for (i = 0; i < 16; i++) {
id_list[i] = 60;
- if (j < h->list_count && i < h->ref_count[j] && h->ref_list[j][i].f.buf[0]) {
+ if (j < h->list_count && i < h->ref_count[j] &&
+ h->ref_list[j][i].f.buf[0]) {
int k;
AVBuffer *buf = h->ref_list[j][i].f.buf[0]->buffer;
for (k = 0; k < h->short_ref_count; k++)
}
}
- ref2frm[0] =
- ref2frm[1] = -1;
+ ref2frm[0] =
+ ref2frm[1] = -1;
for (i = 0; i < 16; i++)
- ref2frm[i + 2] = 4 * id_list[i] +
- (h->ref_list[j][i].reference & 3);
- ref2frm[18 + 0] =
- ref2frm[18 + 1] = -1;
+ ref2frm[i + 2] = 4 * id_list[i] + (h->ref_list[j][i].reference & 3);
+ ref2frm[18 + 0] =
+ ref2frm[18 + 1] = -1;
for (i = 16; i < 48; i++)
ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
(h->ref_list[j][i].reference & 3);
case AV_PICTURE_TYPE_SI:
return 4;
default:
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
} else {
if (curr_mb_field_flag)
top_xy += h->mb_stride &
- (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
+ (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
if (left_mb_field_flag != curr_mb_field_flag)
left_xy[LBOT] += h->mb_stride;
}
* from what the loop filter needs */
if (!CABAC(h) && h->pps.transform_8x8_mode) {
if (IS_8x8DCT(top_type)) {
- nnz_cache[4 + 8 * 0] =
- nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
- nnz_cache[6 + 8 * 0] =
- nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
+ nnz_cache[4 + 8 * 0] =
+ nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
+ nnz_cache[6 + 8 * 0] =
+ nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
}
if (IS_8x8DCT(left_type[LTOP])) {
- nnz_cache[3 + 8 * 1] =
- nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
+ nnz_cache[3 + 8 * 1] =
+ nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
}
if (IS_8x8DCT(left_type[LBOT])) {
- nnz_cache[3 + 8 * 3] =
- nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
+ nnz_cache[3 + 8 * 3] =
+ nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
}
if (IS_8x8DCT(mb_type)) {
if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
h->cabac.bytestream > h->cabac.bytestream_end + 2) {
er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x - 1,
- h->mb_y, ER_MB_END);
+ h->mb_y, ER_MB_END);
if (h->mb_x >= lf_x_start)
loop_filter(h, lf_x_start, h->mb_x + 1);
return 0;
h->mb_x, h->mb_y,
h->cabac.bytestream_end - h->cabac.bytestream);
er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x,
- h->mb_y, ER_MB_ERROR);
- return -1;
+ h->mb_y, ER_MB_ERROR);
+ return AVERROR_INVALIDDATA;
}
if (++h->mb_x >= h->mb_width) {
tprintf(h->avctx, "slice end %d %d\n",
get_bits_count(&h->gb), h->gb.size_in_bits);
er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x - 1,
- h->mb_y, ER_MB_END);
+ h->mb_y, ER_MB_END);
if (h->mb_x > lf_x_start)
loop_filter(h, lf_x_start, h->mb_x);
return 0;
av_log(h->avctx, AV_LOG_ERROR,
"error while decoding MB %d %d\n", h->mb_x, h->mb_y);
er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x,
- h->mb_y, ER_MB_ERROR);
- return -1;
+ h->mb_y, ER_MB_ERROR);
+ return ret;
}
if (++h->mb_x >= h->mb_width) {
if (get_bits_left(&h->gb) == 0) {
er_add_slice(h, h->resync_mb_x, h->resync_mb_y,
- h->mb_x - 1, h->mb_y,
- ER_MB_END);
+ h->mb_x - 1, h->mb_y,
+ ER_MB_END);
return 0;
} else {
er_add_slice(h, h->resync_mb_x, h->resync_mb_y,
- h->mb_x - 1, h->mb_y,
- ER_MB_END);
+ h->mb_x - 1, h->mb_y,
+ ER_MB_END);
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
}
if (get_bits_left(&h->gb) <= 0 && h->mb_skip_run <= 0) {
tprintf(h->avctx, "slice end %d %d\n",
get_bits_count(&h->gb), h->gb.size_in_bits);
+
if (get_bits_left(&h->gb) == 0) {
er_add_slice(h, h->resync_mb_x, h->resync_mb_y,
- h->mb_x - 1, h->mb_y,
- ER_MB_END);
+ h->mb_x - 1, h->mb_y,
+ ER_MB_END);
if (h->mb_x > lf_x_start)
loop_filter(h, lf_x_start, h->mb_x);
return 0;
} else {
er_add_slice(h, h->resync_mb_x, h->resync_mb_y, h->mb_x,
- h->mb_y, ER_MB_ERROR);
+ h->mb_y, ER_MB_ERROR);
- return -1;
+ return AVERROR_INVALIDDATA;
}
}
}
H264Context *hx;
int i;
- if (h->avctx->hwaccel ||
- h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
+ if (h->avctx->hwaccel)
return 0;
if (context_count == 1) {
return decode_slice(avctx, &h);
} else {
for (i = 1; i < context_count; i++) {
- hx = h->thread_context[i];
- hx->er.error_count = 0;
+ hx = h->thread_context[i];
+ hx->er.error_count = 0;
}
avctx->execute(avctx, decode_slice, h->thread_context,
return 0;
}
+static const uint8_t start_code[] = { 0x00, 0x00, 0x01 };
+
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size,
int parse_extradata)
{
int pass = !(avctx->active_thread_type & FF_THREAD_FRAME);
int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
int nal_index;
+ int ret = 0;
h->max_contexts = h->slice_context_count;
if (!(avctx->flags2 & CODEC_FLAG2_CHUNKS)) {
ptr = ff_h264_decode_nal(hx, buf + buf_index, &dst_length,
&consumed, next_avc - buf_index);
if (ptr == NULL || dst_length < 0) {
- buf_index = -1;
+ ret = -1;
goto end;
}
i = buf_index + consumed;
if (h->nal_unit_type != NAL_IDR_SLICE) {
av_log(h->avctx, AV_LOG_ERROR,
"Invalid mix of idr and non-idr slices\n");
- buf_index = -1;
+ ret = -1;
goto end;
}
idr(h); // FIXME ensure we don't lose some frames if there is reordering
case NAL_SLICE:
init_get_bits(&hx->gb, ptr, bit_length);
- hx->intra_gb_ptr =
- hx->inter_gb_ptr = &hx->gb;
+ hx->intra_gb_ptr =
+ hx->inter_gb_ptr = &hx->gb;
hx->data_partitioning = 0;
if ((err = decode_slice_header(hx, h)))
decode_postinit(h, nal_index >= nals_needed);
if (h->avctx->hwaccel &&
- h->avctx->hwaccel->start_frame(h->avctx, NULL, 0) < 0)
- return -1;
- if (CONFIG_H264_VDPAU_DECODER &&
- h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
- ff_vdpau_h264_picture_start(h);
+ (ret = h->avctx->hwaccel->start_frame(h->avctx, NULL, 0)) < 0)
+ return ret;
}
if (hx->redundant_pic_count == 0 &&
hx->slice_type_nos == AV_PICTURE_TYPE_I) &&
avctx->skip_frame < AVDISCARD_ALL) {
if (avctx->hwaccel) {
- if (avctx->hwaccel->decode_slice(avctx,
- &buf[buf_index - consumed],
- consumed) < 0)
- return -1;
- } else if (CONFIG_H264_VDPAU_DECODER &&
- h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) {
- static const uint8_t start_code[] = {
- 0x00, 0x00, 0x01 };
- ff_vdpau_add_data_chunk(h->cur_pic_ptr->f.data[0], start_code,
- sizeof(start_code));
- ff_vdpau_add_data_chunk(h->cur_pic_ptr->f.data[0], &buf[buf_index - consumed],
- consumed);
+ ret = avctx->hwaccel->decode_slice(avctx,
+ &buf[buf_index - consumed],
+ consumed);
+ if (ret < 0)
+ return ret;
} else
context_count++;
}
break;
case NAL_SPS:
init_get_bits(&h->gb, ptr, bit_length);
- if (ff_h264_decode_seq_parameter_set(h) < 0 &&
- h->is_avc && (nalsize != consumed) && nalsize) {
+ ret = ff_h264_decode_seq_parameter_set(h);
+ if (ret < 0 && h->is_avc && (nalsize != consumed) && nalsize) {
av_log(h->avctx, AV_LOG_DEBUG,
"SPS decoding failure, trying again with the complete NAL\n");
init_get_bits(&h->gb, buf + buf_index + 1 - consumed,
ff_h264_decode_seq_parameter_set(h);
}
- if (h264_set_parameter_from_sps(h) < 0) {
- buf_index = -1;
+ ret = h264_set_parameter_from_sps(h);
+ if (ret < 0)
goto end;
- }
+
break;
case NAL_PPS:
init_get_bits(&h->gb, ptr, bit_length);
h->picture_structure == PICT_BOTTOM_FIELD);
}
- return buf_index;
+ return (ret < 0) ? ret : buf_index;
}
/**
int hshift = (i > 0) ? h->chroma_x_shift : 0;
int vshift = (i > 0) ? h->chroma_y_shift : 0;
int off = ((h->sps.crop_left >> hshift) << h->pixel_shift) +
- (h->sps.crop_top >> vshift) * dst->linesize[i];
+ (h->sps.crop_top >> vshift) * dst->linesize[i];
dst->data[i] += off;
}
return 0;
int buf_index = 0;
int ret;
- h->flags = avctx->flags;
+ h->flags = avctx->flags;
/* end of stream, output what is still in the buffers */
out:
buf_index = decode_nal_units(h, buf, buf_size, 0);
if (buf_index < 0)
- return -1;
+ return AVERROR_INVALIDDATA;
if (!h->cur_pic_ptr && h->nal_unit_type == NAL_END_SEQUENCE) {
buf_size = 0;
if (avctx->skip_frame >= AVDISCARD_NONREF)
return 0;
av_log(avctx, AV_LOG_ERROR, "no frame!\n");
- return -1;
+ return AVERROR_INVALIDDATA;
}
if (!(avctx->flags2 & CODEC_FLAG2_CHUNKS) ||
static av_cold int h264_decode_end(AVCodecContext *avctx)
{
- H264Context *h = avctx->priv_data;
+ H264Context *h = avctx->priv_data;
ff_h264_free_context(h);
.update_thread_context = ONLY_IF_THREADS_ENABLED(decode_update_thread_context),
.profiles = NULL_IF_CONFIG_SMALL(profiles),
};
-
-#if CONFIG_H264_VDPAU_DECODER
-AVCodec ff_h264_vdpau_decoder = {
- .name = "h264_vdpau",
- .type = AVMEDIA_TYPE_VIDEO,
- .id = AV_CODEC_ID_H264,
- .priv_data_size = sizeof(H264Context),
- .init = ff_h264_decode_init,
- .close = h264_decode_end,
- .decode = decode_frame,
- .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
- .flush = flush_dpb,
- .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
- .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_H264,
- AV_PIX_FMT_NONE},
- .profiles = NULL_IF_CONFIG_SMALL(profiles),
-};
-#endif