static int qsv_setup_mids(mfxFrameAllocResponse *resp, AVBufferRef *hw_frames_ref,
AVBufferRef *mids_buf)
{
AVHWFramesContext *frames_ctx = (AVHWFramesContext*)hw_frames_ref->data;
AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
QSVMid *mids = (QSVMid*)mids_buf->data;
int nb_surfaces = frames_hwctx->nb_surfaces;
int i;
// the allocated size of the array is two larger than the number of
// surfaces, we store the references to the frames context and the
// QSVMid array there
resp->mids = av_mallocz_array(nb_surfaces + 2, sizeof(*resp->mids));
if (!resp->mids)
return AVERROR(ENOMEM);
for (i = 0; i < nb_surfaces; i++)
resp->mids[i] = &mids[i];
resp->NumFrameActual = nb_surfaces;
resp->mids[resp->NumFrameActual] = (mfxMemId)av_buffer_ref(hw_frames_ref);
if (!resp->mids[resp->NumFrameActual]) {
av_freep(&resp->mids);
return AVERROR(ENOMEM);
}
resp->mids[resp->NumFrameActual + 1] = av_buffer_ref(mids_buf);
if (!resp->mids[resp->NumFrameActual + 1]) {
av_buffer_unref((AVBufferRef**)&resp->mids[resp->NumFrameActual]);
av_freep(&resp->mids);
return AVERROR(ENOMEM);
}
return 0;
}
static int hwmap_filter_frame(AVFilterLink *link, AVFrame *input)
{
AVFilterContext *avctx = link->dst;
AVFilterLink *outlink = avctx->outputs[0];
HWMapContext *ctx = avctx->priv;
AVFrame *map = NULL;
int err;
av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
av_get_pix_fmt_name(input->format),
input->width, input->height, input->pts);
map = av_frame_alloc();
if (!map) {
err = AVERROR(ENOMEM);
goto fail;
}
map->format = outlink->format;
map->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
if (!map->hw_frames_ctx) {
err = AVERROR(ENOMEM);
goto fail;
}
if (ctx->reverse && !input->hw_frames_ctx) {
// If we mapped backwards from hardware to software, we need
// to attach the hardware frame context to the input frame to
// make the mapping visible to av_hwframe_map().
input->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
if (!input->hw_frames_ctx) {
err = AVERROR(ENOMEM);
goto fail;
}
}
err = av_hwframe_map(map, input, ctx->mode);
if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to map frame: %d.\n", err);
goto fail;
}
err = av_frame_copy_props(map, input);
if (err < 0)
goto fail;
av_frame_free(&input);
av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
av_get_pix_fmt_name(map->format),
map->width, map->height, map->pts);
return ff_filter_frame(outlink, map);
fail:
av_frame_free(&input);
av_frame_free(&map);
return err;
}
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
{
int ret, i;
av_assert0(!dst->f.buf[0]);
av_assert0(src->f.buf[0]);
src->tf.f = &src->f;
dst->tf.f = &dst->f;
ret = ff_thread_ref_frame(&dst->tf, &src->tf);
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)
goto fail;
dst->qscale_table = src->qscale_table;
dst->mb_type = src->mb_type;
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])
goto fail;
dst->motion_val[i] = src->motion_val[i];
dst->ref_index[i] = src->ref_index[i];
}
if (src->hwaccel_picture_private) {
dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
if (!dst->hwaccel_priv_buf)
goto fail;
dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
}
for (i = 0; i < 2; i++)
dst->field_poc[i] = src->field_poc[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->recovered = src->recovered;
return 0;
fail:
ff_h264_unref_picture(h, dst);
return ret;
}
static int cudaupload_config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = ctx->inputs[0];
CudaUploadContext *s = ctx->priv;
AVHWFramesContext *hwframe_ctx;
int ret;
av_buffer_unref(&s->hwframe);
s->hwframe = av_hwframe_ctx_alloc(s->hwdevice);
if (!s->hwframe)
return AVERROR(ENOMEM);
hwframe_ctx = (AVHWFramesContext*)s->hwframe->data;
hwframe_ctx->format = AV_PIX_FMT_CUDA;
hwframe_ctx->sw_format = inlink->format;
hwframe_ctx->width = inlink->w;
hwframe_ctx->height = inlink->h;
ret = av_hwframe_ctx_init(s->hwframe);
if (ret < 0)
return ret;
outlink->hw_frames_ctx = av_buffer_ref(s->hwframe);
if (!outlink->hw_frames_ctx)
return AVERROR(ENOMEM);
return 0;
}
/* Makes duplicates of data, side_data, but does not copy any other fields */
static int copy_packet_data(AVPacket *pkt, AVPacket *src, int dup)
{
pkt->data = NULL;
pkt->side_data = NULL;
if (pkt->buf) {
AVBufferRef *ref = av_buffer_ref(src->buf);
if (!ref)
return AVERROR(ENOMEM);
pkt->buf = ref;
pkt->data = ref->data;
} else {
DUP_DATA(pkt->data, src->data, pkt->size, 1, ALLOC_BUF);
}
#if FF_API_DESTRUCT_PACKET
pkt->destruct = dummy_destruct_packet;
#endif
if (pkt->side_data_elems && dup)
pkt->side_data = src->side_data;
if (pkt->side_data_elems && !dup) {
return av_copy_packet_side_data(pkt, src);
}
return 0;
failed_alloc:
av_destruct_packet(pkt);
return AVERROR(ENOMEM);
}
static int config_props(AVFilterLink *link)
{
BufferSourceContext *c = link->src->priv;
switch (link->type) {
case AVMEDIA_TYPE_VIDEO:
link->w = c->w;
link->h = c->h;
link->sample_aspect_ratio = c->pixel_aspect;
if (c->hw_frames_ctx) {
link->hw_frames_ctx = av_buffer_ref(c->hw_frames_ctx);
if (!link->hw_frames_ctx)
return AVERROR(ENOMEM);
}
break;
case AVMEDIA_TYPE_AUDIO:
if (!c->channel_layout)
c->channel_layout = link->channel_layout;
break;
default:
return AVERROR(EINVAL);
}
link->time_base = c->time_base;
link->frame_rate = c->frame_rate;
return 0;
}
int ff_cbs_read_packet(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag,
const AVPacket *pkt)
{
int err;
memset(frag, 0, sizeof(*frag));
if (pkt->buf) {
frag->data_ref = av_buffer_ref(pkt->buf);
if (!frag->data_ref)
return AVERROR(ENOMEM);
frag->data = pkt->data;
frag->data_size = pkt->size;
} else {
err = cbs_fill_fragment_data(ctx, frag, pkt->data, pkt->size);
if (err < 0)
return err;
}
err = ctx->codec->split_fragment(ctx, frag, 0);
if (err < 0)
return err;
return cbs_read_fragment_content(ctx, frag);
}
static inline int vs_create_plane_buffer
(
vs_video_buffer_handler_t *vs_vbhp,
AVBufferRef *vs_buffer_handler,
AVFrame *av_frame,
int av_plane,
int vs_plane
)
{
AVBufferRef *vs_buffer_ref = av_buffer_ref( vs_buffer_handler );
if( !vs_buffer_ref )
{
av_buffer_unref( &vs_buffer_handler );
return -1;
}
av_frame->linesize[av_plane] = vs_vbhp->vsapi->getStride( vs_vbhp->vs_frame_buffer, vs_plane );
int vs_plane_size = vs_vbhp->vsapi->getFrameHeight( vs_vbhp->vs_frame_buffer, vs_plane )
* av_frame->linesize[av_plane];
av_frame->buf[av_plane] = av_buffer_create( vs_vbhp->vsapi->getWritePtr( vs_vbhp->vs_frame_buffer, vs_plane ),
vs_plane_size,
vs_video_unref_buffer_handler,
vs_buffer_ref,
0 );
if( !av_frame->buf[av_plane] )
return -1;
av_frame->data[av_plane] = av_frame->buf[av_plane]->data;
return 0;
}
int av_packet_ref(AVPacket *dst, const AVPacket *src)
{
int ret;
ret = av_packet_copy_props(dst, src);
if (ret < 0)
return ret;
if (!src->buf) {
ret = packet_alloc(&dst->buf, src->size);
if (ret < 0)
goto fail;
if (src->size)
memcpy(dst->buf->data, src->data, src->size);
dst->data = dst->buf->data;
} else {
dst->buf = av_buffer_ref(src->buf);
if (!dst->buf) {
ret = AVERROR(ENOMEM);
goto fail;
}
dst->data = src->data;
}
dst->size = src->size;
return 0;
fail:
av_packet_free_side_data(dst);
return ret;
}
/**
* Update the next thread's AVCodecContext with values from the reference thread's context.
*
* @param dst The destination context.
* @param src The source context.
* @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread
*/
static int update_context_from_thread(AVCodecContext *dst, AVCodecContext *src, int for_user)
{
int err = 0;
if (dst != src) {
dst->time_base = src->time_base;
dst->framerate = src->framerate;
dst->width = src->width;
dst->height = src->height;
dst->pix_fmt = src->pix_fmt;
dst->sw_pix_fmt = src->sw_pix_fmt;
dst->coded_width = src->coded_width;
dst->coded_height = src->coded_height;
dst->has_b_frames = src->has_b_frames;
dst->idct_algo = src->idct_algo;
dst->bits_per_coded_sample = src->bits_per_coded_sample;
dst->sample_aspect_ratio = src->sample_aspect_ratio;
dst->profile = src->profile;
dst->level = src->level;
dst->bits_per_raw_sample = src->bits_per_raw_sample;
dst->ticks_per_frame = src->ticks_per_frame;
dst->color_primaries = src->color_primaries;
dst->color_trc = src->color_trc;
dst->colorspace = src->colorspace;
dst->color_range = src->color_range;
dst->chroma_sample_location = src->chroma_sample_location;
dst->hwaccel = src->hwaccel;
dst->hwaccel_context = src->hwaccel_context;
dst->internal->hwaccel_priv_data = src->internal->hwaccel_priv_data;
if (!!dst->hw_frames_ctx != !!src->hw_frames_ctx ||
(dst->hw_frames_ctx && dst->hw_frames_ctx->data != src->hw_frames_ctx->data)) {
av_buffer_unref(&dst->hw_frames_ctx);
if (src->hw_frames_ctx) {
dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
if (!dst->hw_frames_ctx)
return AVERROR(ENOMEM);
}
}
dst->hwaccel_flags = src->hwaccel_flags;
}
if (for_user) {
#if FF_API_CODED_FRAME
FF_DISABLE_DEPRECATION_WARNINGS
dst->coded_frame = src->coded_frame;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
} else {
if (dst->codec->update_thread_context)
AVBufferRef *av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
{
AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)device_ref_in->data;
const HWContextType *hw_type = device_ctx->internal->hw_type;
AVHWFramesContext *ctx;
AVBufferRef *buf, *device_ref = NULL;;
ctx = av_mallocz(sizeof(*ctx));
if (!ctx)
return NULL;
ctx->internal = av_mallocz(sizeof(*ctx->internal));
if (!ctx->internal)
goto fail;
if (hw_type->frames_priv_size) {
ctx->internal->priv = av_mallocz(hw_type->frames_priv_size);
if (!ctx->internal->priv)
goto fail;
}
if (hw_type->frames_hwctx_size) {
ctx->hwctx = av_mallocz(hw_type->frames_hwctx_size);
if (!ctx->hwctx)
goto fail;
}
device_ref = av_buffer_ref(device_ref_in);
if (!device_ref)
goto fail;
buf = av_buffer_create((uint8_t*)ctx, sizeof(*ctx),
hwframe_ctx_free, NULL,
AV_BUFFER_FLAG_READONLY);
if (!buf)
goto fail;
ctx->av_class = &hwframe_ctx_class;
ctx->device_ref = device_ref;
ctx->device_ctx = device_ctx;
ctx->format = AV_PIX_FMT_NONE;
ctx->sw_format = AV_PIX_FMT_NONE;
ctx->internal->hw_type = hw_type;
return buf;
fail:
if (device_ref)
av_buffer_unref(&device_ref);
if (ctx->internal)
av_freep(&ctx->internal->priv);
av_freep(&ctx->internal);
av_freep(&ctx->hwctx);
av_freep(&ctx);
return NULL;
}
JNIEXPORT void JNICALL Java_bits_jav_codec_JavFrame_nExtendedBufElem__JIJ
( JNIEnv *env, jclass clazz, jlong pointer, jint idx, jlong refPtr )
{
AVFrame *frame = *(AVFrame**)&pointer;
av_buffer_unref( &frame->extended_buf[idx] );
if( refPtr ) {
frame->extended_buf[idx] = av_buffer_ref( *(AVBufferRef**)&refPtr );
}
}
static mfxStatus qsv_frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
{
QSVMid *qsv_mid = mid;
AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)qsv_mid->hw_frames_ref->data;
AVQSVFramesContext *hw_frames_hwctx = hw_frames_ctx->hwctx;
int ret;
if (qsv_mid->locked_frame)
return MFX_ERR_UNDEFINED_BEHAVIOR;
/* Allocate a system memory frame that will hold the mapped data. */
qsv_mid->locked_frame = av_frame_alloc();
if (!qsv_mid->locked_frame)
return MFX_ERR_MEMORY_ALLOC;
qsv_mid->locked_frame->format = hw_frames_ctx->sw_format;
/* wrap the provided handle in a hwaccel AVFrame */
qsv_mid->hw_frame = av_frame_alloc();
if (!qsv_mid->hw_frame)
goto fail;
qsv_mid->hw_frame->data[3] = (uint8_t*)&qsv_mid->surf;
qsv_mid->hw_frame->format = AV_PIX_FMT_QSV;
// doesn't really matter what buffer is used here
qsv_mid->hw_frame->buf[0] = av_buffer_alloc(1);
if (!qsv_mid->hw_frame->buf[0])
goto fail;
qsv_mid->hw_frame->width = hw_frames_ctx->width;
qsv_mid->hw_frame->height = hw_frames_ctx->height;
qsv_mid->hw_frame->hw_frames_ctx = av_buffer_ref(qsv_mid->hw_frames_ref);
if (!qsv_mid->hw_frame->hw_frames_ctx)
goto fail;
qsv_mid->surf.Info = hw_frames_hwctx->surfaces[0].Info;
qsv_mid->surf.Data.MemId = qsv_mid->handle;
/* map the data to the system memory */
ret = av_hwframe_map(qsv_mid->locked_frame, qsv_mid->hw_frame,
AV_HWFRAME_MAP_DIRECT);
if (ret < 0)
goto fail;
ptr->Pitch = qsv_mid->locked_frame->linesize[0];
ptr->Y = qsv_mid->locked_frame->data[0];
ptr->U = qsv_mid->locked_frame->data[1];
ptr->V = qsv_mid->locked_frame->data[1] + 1;
return MFX_ERR_NONE;
fail:
av_frame_free(&qsv_mid->hw_frame);
av_frame_free(&qsv_mid->locked_frame);
return MFX_ERR_MEMORY_ALLOC;
}
FF_DISABLE_DEPRECATION_WARNINGS
#define ALLOC_MALLOC(data, size) data = av_malloc(size)
#define ALLOC_BUF(data, size) \
do { \
av_buffer_realloc(&pkt->buf, size); \
data = pkt->buf ? pkt->buf->data : NULL; \
} while (0)
#define DUP_DATA(dst, src, size, padding, ALLOC) \
do { \
void *data; \
if (padding) { \
if ((unsigned)(size) > \
(unsigned)(size) + AV_INPUT_BUFFER_PADDING_SIZE) \
goto failed_alloc; \
ALLOC(data, size + AV_INPUT_BUFFER_PADDING_SIZE); \
} else { \
ALLOC(data, size); \
} \
if (!data) \
goto failed_alloc; \
memcpy(data, src, size); \
if (padding) \
memset((uint8_t *)data + size, 0, \
AV_INPUT_BUFFER_PADDING_SIZE); \
dst = data; \
} while (0)
/* Makes duplicates of data, side_data, but does not copy any other fields */
static int copy_packet_data(AVPacket *pkt, const AVPacket *src, int dup)
{
pkt->data = NULL;
pkt->side_data = NULL;
pkt->side_data_elems = 0;
if (pkt->buf) {
AVBufferRef *ref = av_buffer_ref(src->buf);
if (!ref)
return AVERROR(ENOMEM);
pkt->buf = ref;
pkt->data = ref->data;
} else {
DUP_DATA(pkt->data, src->data, pkt->size, 1, ALLOC_BUF);
}
if (src->side_data_elems && dup) {
pkt->side_data = src->side_data;
pkt->side_data_elems = src->side_data_elems;
}
if (src->side_data_elems && !dup) {
return av_copy_packet_side_data(pkt, src);
}
return 0;
failed_alloc:
av_packet_unref(pkt);
return AVERROR(ENOMEM);
}
JNIEXPORT jlong JNICALL Java_bits_jav_codec_JavFrame_nExtendedBufElem__JI
( JNIEnv *env, jclass clazz, jlong pointer, jint idx )
{
AVFrame *frame = *(AVFrame**)&pointer;
AVBufferRef *ref = frame->extended_buf[idx];
if( ref == NULL ) {
return 0;
}
ref = av_buffer_ref( ref );
return *(jlong*)&ref;
}
static av_cold int init_processing_chain(AVFilterContext *ctx, int in_width, int in_height,
int out_width, int out_height)
{
CUDAScaleContext *s = ctx->priv;
AVHWFramesContext *in_frames_ctx;
enum AVPixelFormat in_format;
enum AVPixelFormat out_format;
int ret;
/* check that we have a hw context */
if (!ctx->inputs[0]->hw_frames_ctx) {
av_log(ctx, AV_LOG_ERROR, "No hw context provided on input\n");
return AVERROR(EINVAL);
}
in_frames_ctx = (AVHWFramesContext*)ctx->inputs[0]->hw_frames_ctx->data;
in_format = in_frames_ctx->sw_format;
out_format = (s->format == AV_PIX_FMT_NONE) ? in_format : s->format;
if (!format_is_supported(in_format)) {
av_log(ctx, AV_LOG_ERROR, "Unsupported input format: %s\n",
av_get_pix_fmt_name(in_format));
return AVERROR(ENOSYS);
}
if (!format_is_supported(out_format)) {
av_log(ctx, AV_LOG_ERROR, "Unsupported output format: %s\n",
av_get_pix_fmt_name(out_format));
return AVERROR(ENOSYS);
}
if (in_width == out_width && in_height == out_height)
s->passthrough = 1;
s->in_fmt = in_format;
s->out_fmt = out_format;
s->planes_in[0].width = in_width;
s->planes_in[0].height = in_height;
s->planes_out[0].width = out_width;
s->planes_out[0].height = out_height;
ret = init_stage(s, in_frames_ctx->device_ref);
if (ret < 0)
return ret;
ctx->outputs[0]->hw_frames_ctx = av_buffer_ref(s->frames_ctx);
if (!ctx->outputs[0]->hw_frames_ctx)
return AVERROR(ENOMEM);
return 0;
}
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
{
AVHWFramesContext *ctx = (AVHWFramesContext*)hwframe_ref->data;
int ret;
if (ctx->internal->source_frames) {
// This is a derived frame context, so we allocate in the source
// and map the frame immediately.
AVFrame *src_frame;
src_frame = av_frame_alloc();
if (!src_frame)
return AVERROR(ENOMEM);
ret = av_hwframe_get_buffer(ctx->internal->source_frames,
src_frame, 0);
if (ret < 0)
return ret;
ret = av_hwframe_map(frame, src_frame, 0);
if (ret) {
av_log(ctx, AV_LOG_ERROR, "Failed to map frame into derived "
"frame context: %d.\n", ret);
av_frame_free(&src_frame);
return ret;
}
// Free the source frame immediately - the mapped frame still
// contains a reference to it.
av_frame_free(&src_frame);
return 0;
}
if (!ctx->internal->hw_type->frames_get_buffer)
return AVERROR(ENOSYS);
if (!ctx->pool)
return AVERROR(EINVAL);
frame->hw_frames_ctx = av_buffer_ref(hwframe_ref);
if (!frame->hw_frames_ctx)
return AVERROR(ENOMEM);
ret = ctx->internal->hw_type->frames_get_buffer(ctx, frame);
if (ret < 0) {
av_buffer_unref(&frame->hw_frames_ctx);
return ret;
}
return 0;
}
static int hw_decoder_init(AVCodecContext *ctx, const enum AVHWDeviceType type)
{
int err = 0;
if ((err = av_hwdevice_ctx_create(&hw_device_ctx, type,
NULL, NULL, 0)) < 0) {
fprintf(stderr, "Failed to create specified HW device.\n");
return err;
}
ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
return err;
}
int ff_hwframe_map_create(AVBufferRef *hwframe_ref,
AVFrame *dst, const AVFrame *src,
void (*unmap)(AVHWFramesContext *ctx,
HWMapDescriptor *hwmap),
void *priv)
{
AVHWFramesContext *ctx = (AVHWFramesContext*)hwframe_ref->data;
HWMapDescriptor *hwmap;
int ret;
hwmap = av_mallocz(sizeof(*hwmap));
if (!hwmap) {
ret = AVERROR(ENOMEM);
goto fail;
}
hwmap->source = av_frame_alloc();
if (!hwmap->source) {
ret = AVERROR(ENOMEM);
goto fail;
}
ret = av_frame_ref(hwmap->source, src);
if (ret < 0)
goto fail;
hwmap->hw_frames_ctx = av_buffer_ref(hwframe_ref);
if (!hwmap->hw_frames_ctx) {
ret = AVERROR(ENOMEM);
goto fail;
}
hwmap->unmap = unmap;
hwmap->priv = priv;
dst->buf[0] = av_buffer_create((uint8_t*)hwmap, sizeof(*hwmap),
&ff_hwframe_unmap, ctx, 0);
if (!dst->buf[0]) {
ret = AVERROR(ENOMEM);
goto fail;
}
return 0;
fail:
if (hwmap) {
av_buffer_unref(&hwmap->hw_frames_ctx);
av_frame_free(&hwmap->source);
}
av_free(hwmap);
return ret;
}
int Packet::SetPacket(AVPacket *pkt)
{
if (pkt->buf) {
ASSERT(!m_Buf);
m_Buf = av_buffer_ref(pkt->buf);
if (!m_Buf)
return -1;
m_Data = m_Buf->data;
m_DataSize = pkt->size;
return 0;
} else {
return SetData(pkt->data, pkt->size);
}
}
static int open_input_file(const char *filename)
{
int ret;
AVCodec *decoder = NULL;
AVStream *video = NULL;
if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
fprintf(stderr, "Cannot open input file '%s', Error code: %s\n",
filename, av_err2str(ret));
return ret;
}
if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
fprintf(stderr, "Cannot find input stream information. Error code: %s\n",
av_err2str(ret));
return ret;
}
ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
if (ret < 0) {
fprintf(stderr, "Cannot find a video stream in the input file. "
"Error code: %s\n", av_err2str(ret));
return ret;
}
video_stream = ret;
if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
return AVERROR(ENOMEM);
video = ifmt_ctx->streams[video_stream];
if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {
fprintf(stderr, "avcodec_parameters_to_context error. Error code: %s\n",
av_err2str(ret));
return ret;
}
decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
if (!decoder_ctx->hw_device_ctx) {
fprintf(stderr, "A hardware device reference create failed.\n");
return AVERROR(ENOMEM);
}
decoder_ctx->get_format = get_vaapi_format;
if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0)
fprintf(stderr, "Failed to open codec for decoding. Error code: %s\n",
av_err2str(ret));
return ret;
}
static int mp3_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MP3Context *mp3 = s->priv_data;
if (pkt->stream_index == mp3->audio_stream_idx) {
if (mp3->pics_to_write) {
/* buffer audio packets until we get all the pictures */
AVPacketList *pktl = av_mallocz(sizeof(*pktl));
if (!pktl)
return AVERROR(ENOMEM);
pktl->pkt = *pkt;
pktl->pkt.buf = av_buffer_ref(pkt->buf);
if (!pktl->pkt.buf) {
av_freep(&pktl);
return AVERROR(ENOMEM);
}
if (mp3->queue_end)
mp3->queue_end->next = pktl;
else
mp3->queue = pktl;
mp3->queue_end = pktl;
} else
return mp3_write_audio_packet(s, pkt);
} else {
int ret;
/* warn only once for each stream */
if (s->streams[pkt->stream_index]->nb_frames == 1) {
av_log(s, AV_LOG_WARNING, "Got more than one picture in stream %d,"
" ignoring.\n", pkt->stream_index);
}
if (!mp3->pics_to_write || s->streams[pkt->stream_index]->nb_frames >= 1)
return 0;
if ((ret = ff_id3v2_write_apic(s, &mp3->id3, pkt)) < 0)
return ret;
mp3->pics_to_write--;
/* flush the buffered audio packets */
if (!mp3->pics_to_write &&
(ret = mp3_queue_flush(s)) < 0)
return ret;
}
return 0;
}
static int opencl_filter_set_device(AVFilterContext *avctx,
AVBufferRef *device)
{
OpenCLFilterContext *ctx = avctx->priv;
av_buffer_unref(&ctx->device_ref);
ctx->device_ref = av_buffer_ref(device);
if (!ctx->device_ref)
return AVERROR(ENOMEM);
ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
ctx->hwctx = ctx->device->hwctx;
return 0;
}
HRESULT CDecD3D11::DeliverD3D11ReadbackDirect(LAVFrame *pFrame)
{
AVD3D11VADeviceContext *pDeviceContext = (AVD3D11VADeviceContext *)((AVHWDeviceContext *)m_pDevCtx->data)->hwctx;
AVFrame *src = (AVFrame *)pFrame->priv_data;
if (m_pD3D11StagingTexture == nullptr)
{
D3D11_TEXTURE2D_DESC texDesc = { 0 };
((ID3D11Texture2D *)src->data[0])->GetDesc(&texDesc);
texDesc.ArraySize = 1;
texDesc.Usage = D3D11_USAGE_STAGING;
texDesc.BindFlags = 0;
texDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
HRESULT hr = pDeviceContext->device->CreateTexture2D(&texDesc, nullptr, &m_pD3D11StagingTexture);
if (FAILED(hr))
{
ReleaseFrame(&pFrame);
return E_FAIL;
}
}
pDeviceContext->lock(pDeviceContext->lock_ctx);
pDeviceContext->device_context->CopySubresourceRegion(m_pD3D11StagingTexture, 0, 0, 0, 0, (ID3D11Texture2D *)src->data[0], (UINT)(intptr_t)src->data[1], nullptr);
pDeviceContext->unlock(pDeviceContext->lock_ctx);
av_frame_free(&src);
D3D11DirectPrivate *c = new D3D11DirectPrivate;
c->pDeviceContex = av_buffer_ref(m_pDevCtx);
c->pStagingTexture = m_pD3D11StagingTexture;
m_pD3D11StagingTexture->AddRef();
pFrame->priv_data = c;
pFrame->destruct = d3d11_direct_free;
GetPixelFormat(&pFrame->format, &pFrame->bpp);
pFrame->direct = true;
pFrame->direct_lock = d3d11_direct_lock;
pFrame->direct_unlock = d3d11_direct_unlock;
return Deliver(pFrame);
}
static int scale_vaapi_config_input(AVFilterLink *inlink)
{
AVFilterContext *avctx = inlink->dst;
ScaleVAAPIContext *ctx = avctx->priv;
scale_vaapi_pipeline_uninit(ctx);
if (!inlink->hw_frames_ctx) {
av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
"required to associate the processing device.\n");
return AVERROR(EINVAL);
}
ctx->input_frames_ref = av_buffer_ref(inlink->hw_frames_ctx);
ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
return 0;
}
int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param)
{
BufferSourceContext *s = ctx->priv;
if (param->time_base.num > 0 && param->time_base.den > 0)
s->time_base = param->time_base;
switch (ctx->filter->outputs[0].type) {
case AVMEDIA_TYPE_VIDEO:
if (param->format != AV_PIX_FMT_NONE) {
s->got_format_from_params = 1;
s->pix_fmt = param->format;
}
if (param->width > 0)
s->w = param->width;
if (param->height > 0)
s->h = param->height;
if (param->sample_aspect_ratio.num > 0 && param->sample_aspect_ratio.den > 0)
s->pixel_aspect = param->sample_aspect_ratio;
if (param->frame_rate.num > 0 && param->frame_rate.den > 0)
s->frame_rate = param->frame_rate;
if (param->hw_frames_ctx) {
av_buffer_unref(&s->hw_frames_ctx);
s->hw_frames_ctx = av_buffer_ref(param->hw_frames_ctx);
if (!s->hw_frames_ctx)
return AVERROR(ENOMEM);
}
break;
case AVMEDIA_TYPE_AUDIO:
if (param->format != AV_SAMPLE_FMT_NONE) {
s->got_format_from_params = 1;
s->sample_fmt = param->format;
}
if (param->sample_rate > 0)
s->sample_rate = param->sample_rate;
if (param->channel_layout)
s->channel_layout = param->channel_layout;
break;
default:
return AVERROR_BUG;
}
return 0;
}
static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession session,
AVBufferRef *hw_frames_ref)
{
int ret;
if (session) {
q->session = session;
} else if (hw_frames_ref) {
if (q->internal_session) {
MFXClose(q->internal_session);
q->internal_session = NULL;
}
av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
q->frames_ctx.hw_frames_ctx = av_buffer_ref(hw_frames_ref);
if (!q->frames_ctx.hw_frames_ctx)
return AVERROR(ENOMEM);
ret = ff_qsv_init_session_hwcontext(avctx, &q->internal_session,
&q->frames_ctx, q->load_plugins,
q->iopattern == MFX_IOPATTERN_OUT_OPAQUE_MEMORY);
if (ret < 0) {
av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
return ret;
}
q->session = q->internal_session;
} else {
if (!q->internal_session) {
ret = ff_qsv_init_internal_session(avctx, &q->internal_session,
q->load_plugins);
if (ret < 0)
return ret;
}
q->session = q->internal_session;
}
/* make sure the decoder is uninitialized */
MFXVideoDECODE_Close(q->session);
return 0;
}
static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt)
{
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
RawVideoContext *context = avctx->priv_data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int need_copy = !avpkt->buf || context->is_2_4_bpp || context->is_yuv2;
int res;
AVFrame *frame = data;
AVPicture *picture = data;
frame->pict_type = AV_PICTURE_TYPE_I;
frame->key_frame = 1;
frame->reordered_opaque = avctx->reordered_opaque;
frame->pkt_pts = avctx->pkt->pts;
if (buf_size < context->frame_size - (avctx->pix_fmt == AV_PIX_FMT_PAL8 ?
AVPALETTE_SIZE : 0))
return -1;
if (need_copy)
frame->buf[0] = av_buffer_alloc(context->frame_size);
else
frame->buf[0] = av_buffer_ref(avpkt->buf);
if (!frame->buf[0])
return AVERROR(ENOMEM);
//2bpp and 4bpp raw in avi and mov (yes this is ugly ...)
if (context->is_2_4_bpp) {
int i;
uint8_t *dst = frame->buf[0]->data;
buf_size = context->frame_size - AVPALETTE_SIZE;
if (avctx->bits_per_coded_sample == 4) {
for (i = 0; 2 * i + 1 < buf_size; i++) {
dst[2 * i + 0] = buf[i] >> 4;
dst[2 * i + 1] = buf[i] & 15;
}
} else {
for (i = 0; 4 * i + 3 < buf_size; i++) {
int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)
{
NVDECContext *ctx = avctx->internal->hwaccel_priv_data;
FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
NVDECFrame *cf = NULL;
int ret;
ctx->bitstream_len = 0;
ctx->nb_slices = 0;
if (fdd->hwaccel_priv)
return 0;
cf = av_mallocz(sizeof(*cf));
if (!cf)
return AVERROR(ENOMEM);
cf->decoder_ref = av_buffer_ref(ctx->decoder_ref);
if (!cf->decoder_ref) {
ret = AVERROR(ENOMEM);
goto fail;
}
cf->idx_ref = av_buffer_pool_get(ctx->decoder_pool);
if (!cf->idx_ref) {
av_log(avctx, AV_LOG_ERROR, "No decoder surfaces left\n");
ret = AVERROR(ENOMEM);
goto fail;
}
cf->idx = *(unsigned int*)cf->idx_ref->data;
fdd->hwaccel_priv = cf;
fdd->hwaccel_priv_free = nvdec_fdd_priv_free;
fdd->post_process = nvdec_retrieve_data;
return 0;
fail:
nvdec_fdd_priv_free(cf);
return ret;
}
static int hwdownload_config_input(AVFilterLink *inlink)
{
AVFilterContext *avctx = inlink->dst;
HWDownloadContext *ctx = avctx->priv;
av_buffer_unref(&ctx->hwframes_ref);
if (!inlink->hw_frames_ctx) {
av_log(ctx, AV_LOG_ERROR, "The input must have a hardware frame "
"reference.\n");
return AVERROR(EINVAL);
}
ctx->hwframes_ref = av_buffer_ref(inlink->hw_frames_ctx);
if (!ctx->hwframes_ref)
return AVERROR(ENOMEM);
ctx->hwframes = (AVHWFramesContext*)ctx->hwframes_ref->data;
return 0;
}