#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#include "libavutil/stereo3d.h"
-#include "libavutil/timer.h"
+#include "libavutil/video_enc_params.h"
+
#include "internal.h"
#include "bytestream.h"
#include "cabac.h"
#include "h264_mvpred.h"
#include "h264_ps.h"
#include "golomb.h"
-#include "hwaccel.h"
+#include "hwconfig.h"
#include "mathops.h"
#include "me_cmp.h"
#include "mpegutils.h"
{
const int big_mb_num = h->mb_stride * (h->mb_height + 1);
const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1);
+ const int st_size = big_mb_num + h->mb_stride;
int x, y;
- FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
- row_mb_num, 8 * sizeof(uint8_t), fail)
+ if (!FF_ALLOCZ_TYPED_ARRAY(h->intra4x4_pred_mode, row_mb_num * 8) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->non_zero_count, big_mb_num) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->slice_table_base, st_size) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->cbp_table, big_mb_num) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->chroma_pred_mode_table, big_mb_num) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->mvd_table[0], row_mb_num * 8) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->mvd_table[1], row_mb_num * 8) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->direct_table, big_mb_num * 4) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->list_counts, big_mb_num) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->mb2b_xy, big_mb_num) ||
+ !FF_ALLOCZ_TYPED_ARRAY(h->mb2br_xy, big_mb_num))
+ return AVERROR(ENOMEM);
h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
-
- FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
- big_mb_num * 48 * sizeof(uint8_t), fail)
- FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base,
- (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail)
- FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table,
- big_mb_num * sizeof(uint16_t), fail)
- FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
- big_mb_num * sizeof(uint8_t), fail)
- FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0],
- row_mb_num, 16 * sizeof(uint8_t), fail);
- FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],
- row_mb_num, 16 * sizeof(uint8_t), fail);
h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
-
- FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
- 4 * big_mb_num * sizeof(uint8_t), fail);
- FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
- big_mb_num * sizeof(uint8_t), fail)
-
memset(h->slice_table_base, -1,
- (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));
+ st_size * sizeof(*h->slice_table_base));
h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
-
- FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,
- big_mb_num * sizeof(uint32_t), fail);
- FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,
- big_mb_num * sizeof(uint32_t), fail);
for (y = 0; y < h->mb_height; y++)
for (x = 0; x < h->mb_width; x++) {
const int mb_xy = x + y * h->mb_stride;
}
return 0;
-
-fail:
- ff_h264_free_tables(h);
- return AVERROR(ENOMEM);
}
/**
if (sl != h->slice_ctx) {
memset(er, 0, sizeof(*er));
- } else
- if (CONFIG_ERROR_RESILIENCE) {
+ } else if (CONFIG_ERROR_RESILIENCE) {
+ const int er_size = h->mb_height * h->mb_stride * (4*sizeof(int) + 1);
/* init ER */
er->avctx = h->avctx;
er->b8_stride = h->mb_width * 2 + 1;
// error resilience code looks cleaner with this
- FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
- (h->mb_num + 1) * sizeof(int), fail);
+ if (!FF_ALLOCZ_TYPED_ARRAY(er->mb_index2xy, h->mb_num + 1) ||
+ !FF_ALLOCZ_TYPED_ARRAY(er->error_status_table, mb_array_size) ||
+ !FF_ALLOCZ_TYPED_ARRAY(er->er_temp_buffer, er_size) ||
+ !FF_ALLOCZ_TYPED_ARRAY(sl->dc_val_base, yc_size))
+ return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
for (y = 0; y < h->mb_height; y++)
for (x = 0; x < h->mb_width; x++)
er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
h->mb_stride + h->mb_width;
-
- FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
- mb_array_size * sizeof(uint8_t), fail);
-
- FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
- h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);
-
- FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
- yc_size * sizeof(int16_t), fail);
er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2;
er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1;
er->dc_val[2] = er->dc_val[1] + c_size;
}
return 0;
-
-fail:
- return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
}
static int h264_init_context(AVCodecContext *avctx, H264Context *h)
h->width_from_caller = avctx->width;
h->height_from_caller = avctx->height;
- h->picture_structure = PICT_FRAME;
h->workaround_bugs = avctx->workaround_bugs;
h->flags = avctx->flags;
h->poc.prev_poc_msb = 1 << 16;
ff_h264_sei_uninit(&h->sei);
- avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
-
h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx));
if (!h->slice_ctx) {
}
avctx->ticks_per_frame = 2;
- if (avctx->extradata_size > 0 && avctx->extradata) {
- ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
- &h->ps, &h->is_avc, &h->nal_length_size,
- avctx->err_recognition, avctx);
- if (ret < 0) {
- h264_decode_end(avctx);
- return ret;
+ if (!avctx->internal->is_copy) {
+ if (avctx->extradata_size > 0 && avctx->extradata) {
+ ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
+ &h->ps, &h->is_avc, &h->nal_length_size,
+ avctx->err_recognition, avctx);
+ if (ret < 0) {
+ int explode = avctx->err_recognition & AV_EF_EXPLODE;
+ av_log(avctx, explode ? AV_LOG_ERROR: AV_LOG_WARNING,
+ "Error decoding the extradata\n");
+ if (explode) {
+ return ret;
+ }
+ ret = 0;
+ }
}
}
h->avctx->has_b_frames = h->ps.sps->num_reorder_frames;
}
- avctx->internal->allocate_progress = 1;
-
ff_h264_flush_change(h);
if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))
return 0;
}
-#if HAVE_THREADS
-static int decode_init_thread_copy(AVCodecContext *avctx)
-{
- H264Context *h = avctx->priv_data;
- int ret;
-
- if (!avctx->internal->is_copy)
- return 0;
-
- memset(h, 0, sizeof(*h));
-
- ret = h264_init_context(avctx, h);
- if (ret < 0)
- return ret;
-
- h->context_initialized = 0;
-
- return 0;
-}
-#endif
-
/**
* instantaneous decoder refresh.
*/
h->poc.prev_frame_num =
h->poc.prev_frame_num_offset = 0;
h->poc.prev_poc_msb = 1<<16;
- h->poc.prev_poc_lsb = 0;
+ h->poc.prev_poc_lsb = -1;
for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
h->last_pocs[i] = INT_MIN;
}
h->mmco_reset = 1;
}
-/* forget old pics after a seek */
-static void flush_dpb(AVCodecContext *avctx)
+static void h264_decode_flush(AVCodecContext *avctx)
{
H264Context *h = avctx->priv_data;
int i;
h->is_avc = 1;
}
- ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
- h->nal_length_size, avctx->codec_id, avctx->flags2 & AV_CODEC_FLAG2_FAST);
+ ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc, h->nal_length_size,
+ avctx->codec_id, 0, 0);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
"Error splitting the input into NAL units.\n");
goto end;
}
if(!idr_cleared) {
- if (h->current_slice && (avctx->active_thread_type & FF_THREAD_SLICE)) {
- av_log(h, AV_LOG_ERROR, "invalid mixed IDR / non IDR frames cannot be decoded in slice multithreading mode\n");
- ret = AVERROR_INVALIDDATA;
- goto end;
- }
idr(h); // FIXME ensure we don't lose some frames if there is reordering
}
idr_cleared = 1;
if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
goto end;
+ // set decode_error_flags to allow users to detect concealed decoding errors
+ if ((ret < 0 || h->slice_ctx->er.error_occurred) && h->cur_pic_ptr) {
+ h->cur_pic_ptr->f->decode_error_flags |= FF_DECODE_ERROR_DECODE_SLICES;
+ }
+
ret = 0;
end:
* past end by one (callers fault) and resync_mb_y != 0
* causes problems for the first MB line, too.
*/
- if (!FIELD_PICTURE(h) && h->current_slice &&
- h->ps.sps == (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data &&
- h->enable_er) {
+ if (!FIELD_PICTURE(h) && h->current_slice && h->enable_er) {
H264SliceContext *sl = h->slice_ctx;
int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
return pos;
}
+static int h264_export_enc_params(AVFrame *f, H264Picture *p)
+{
+ AVVideoEncParams *par;
+ unsigned int nb_mb = p->mb_height * p->mb_width;
+ unsigned int x, y;
+
+ par = av_video_enc_params_create_side_data(f, AV_VIDEO_ENC_PARAMS_H264, nb_mb);
+ if (!par)
+ return AVERROR(ENOMEM);
+
+ par->qp = p->pps->init_qp;
+
+ par->delta_qp[1][0] = p->pps->chroma_qp_index_offset[0];
+ par->delta_qp[1][1] = p->pps->chroma_qp_index_offset[0];
+ par->delta_qp[2][0] = p->pps->chroma_qp_index_offset[1];
+ par->delta_qp[2][1] = p->pps->chroma_qp_index_offset[1];
+
+ for (y = 0; y < p->mb_height; y++)
+ for (x = 0; x < p->mb_width; x++) {
+ const unsigned int block_idx = y * p->mb_width + x;
+ const unsigned int mb_xy = y * p->mb_stride + x;
+ AVVideoBlockParams *b = av_video_enc_params_block(par, block_idx);
+
+ b->src_x = x * 16;
+ b->src_y = y * 16;
+ b->w = 16;
+ b->h = 16;
+
+ b->delta_qp = p->qscale_table[mb_xy] - par->qp;
+ }
+
+ return 0;
+}
+
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
{
AVFrame *src = srcp->f;
if (srcp->sei_recovery_frame_cnt == 0)
dst->key_frame = 1;
+ if (h->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
+ ret = h264_export_enc_params(dst, srcp);
+ if (ret < 0)
+ goto fail;
+ }
+
return 0;
+fail:
+ av_frame_unref(dst);
+ return ret;
}
-static int is_extra(const uint8_t *buf, int buf_size)
+static int is_avcc_extradata(const uint8_t *buf, int buf_size)
{
int cnt= buf[5]&0x1f;
const uint8_t *p= buf+6;
if (buf_size == 0)
return send_next_delayed_frame(h, pict, got_frame, 0);
- if (h->is_avc && av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {
- int side_size;
+ if (av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {
+ size_t side_size;
uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
- if (is_extra(side, side_size))
- ff_h264_decode_extradata(side, side_size,
- &h->ps, &h->is_avc, &h->nal_length_size,
- avctx->err_recognition, avctx);
+ ff_h264_decode_extradata(side, side_size,
+ &h->ps, &h->is_avc, &h->nal_length_size,
+ avctx->err_recognition, avctx);
}
if (h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC) {
- if (is_extra(buf, buf_size))
+ if (is_avcc_extradata(buf, buf_size))
return ff_h264_decode_extradata(buf, buf_size,
&h->ps, &h->is_avc, &h->nal_length_size,
avctx->err_recognition, avctx);
#define OFFSET(x) offsetof(H264Context, x)
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+#define VDX VD | AV_OPT_FLAG_EXPORT
static const AVOption h264_options[] = {
- { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0 },
- { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 },
+ { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VDX },
+ { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, VDX },
{ "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD },
{ "x264_build", "Assume this x264 version if no x264 version found in any SEI", OFFSET(x264_build), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VD },
{ NULL },
.version = LIBAVUTIL_VERSION_INT,
};
-AVCodec ff_h264_decoder = {
+const AVCodec ff_h264_decoder = {
.name = "h264",
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
.type = AVMEDIA_TYPE_VIDEO,
.capabilities = /*AV_CODEC_CAP_DRAW_HORIZ_BAND |*/ AV_CODEC_CAP_DR1 |
AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS |
AV_CODEC_CAP_FRAME_THREADS,
- .hw_configs = (const AVCodecHWConfigInternal*[]) {
+ .hw_configs = (const AVCodecHWConfigInternal *const []) {
#if CONFIG_H264_DXVA2_HWACCEL
HWACCEL_DXVA2(h264),
#endif
#endif
NULL
},
- .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING,
- .flush = flush_dpb,
- .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
+ .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
+ FF_CODEC_CAP_ALLOCATE_PROGRESS | FF_CODEC_CAP_INIT_CLEANUP,
+ .flush = h264_decode_flush,
.update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
+ .update_thread_context_for_user = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context_for_user),
.profiles = NULL_IF_CONFIG_SMALL(ff_h264_profiles),
.priv_class = &h264_class,
};
projects / ffmpeg / blobdiff