#include <inttypes.h>
#include "libavutil/attributes.h"
+#include "libavutil/emms.h"
#include "libavutil/imgutils.h"
#include "libavutil/internal.h"
#include "libavutil/mem_internal.h"
#include "avcodec.h"
#include "codec_internal.h"
+#include "decode.h"
#include "error_resilience.h"
+#include "hwaccel_internal.h"
#include "hwconfig.h"
#include "idctdsp.h"
#include "internal.h"
#include "mpeg_er.h"
#include "mpeg12.h"
+#include "mpeg12codecs.h"
#include "mpeg12data.h"
#include "mpeg12dec.h"
#include "mpegutils.h"
unsigned aspect_ratio_info;
AVRational save_aspect;
int save_width, save_height, save_progressive_seq;
- int rc_buffer_size;
AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */
unsigned frame_rate_index;
int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
int16_t *block, int n)
{
int level, i, j, run;
- RLTable *rl = &ff_rl_mpeg1;
uint8_t *const scantable = s->intra_scantable.permutated;
const uint16_t *quant_matrix = s->inter_matrix;
const int qscale = s->qscale;
}
/* now quantify & encode AC coefficients */
for (;;) {
- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
+ GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
TEX_VLC_BITS, 2, 0);
if (level != 0) {
int16_t *block, int n)
{
int level, i, j, run;
- RLTable *rl = &ff_rl_mpeg1;
uint8_t *const scantable = s->intra_scantable.permutated;
const int qscale = s->qscale;
/* now quantify & encode AC coefficients */
for (;;) {
- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
+ GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
TEX_VLC_BITS, 2, 0);
if (level != 0) {
int16_t *block, int n)
{
int level, i, j, run;
- RLTable *rl = &ff_rl_mpeg1;
uint8_t *const scantable = s->intra_scantable.permutated;
const uint16_t *quant_matrix;
const int qscale = s->qscale;
/* now quantify & encode AC coefficients */
for (;;) {
- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
+ GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
TEX_VLC_BITS, 2, 0);
if (level != 0) {
int16_t *block, int n)
{
int level, i, j, run;
- RLTable *rl = &ff_rl_mpeg1;
uint8_t *const scantable = s->intra_scantable.permutated;
const int qscale = s->qscale;
OPEN_READER(re, &s->gb);
/* now quantify & encode AC coefficients */
for (;;) {
- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
+ GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc, TEX_VLC_BITS, 2, 0);
if (level != 0) {
i += run;
{
int level, dc, diff, i, j, run;
int component;
- RLTable *rl;
+ const RL_VLC_ELEM *rl_vlc;
uint8_t *const scantable = s->intra_scantable.permutated;
const uint16_t *quant_matrix;
const int qscale = s->qscale;
mismatch = block[0] ^ 1;
i = 0;
if (s->intra_vlc_format)
- rl = &ff_rl_mpeg2;
+ rl_vlc = ff_mpeg2_rl_vlc;
else
- rl = &ff_rl_mpeg1;
+ rl_vlc = ff_mpeg1_rl_vlc;
{
OPEN_READER(re, &s->gb);
/* now quantify & encode AC coefficients */
for (;;) {
UPDATE_CACHE(re, &s->gb);
- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc,
TEX_VLC_BITS, 2, 0);
if (level == 127) {
{
int level, dc, diff, i, j, run;
int component;
- RLTable *rl;
+ const RL_VLC_ELEM *rl_vlc;
uint8_t *const scantable = s->intra_scantable.permutated;
const uint16_t *quant_matrix;
const int qscale = s->qscale;
block[0] = dc * (1 << (3 - s->intra_dc_precision));
i = 0;
if (s->intra_vlc_format)
- rl = &ff_rl_mpeg2;
+ rl_vlc = ff_mpeg2_rl_vlc;
else
- rl = &ff_rl_mpeg1;
+ rl_vlc = ff_mpeg1_rl_vlc;
{
OPEN_READER(re, &s->gb);
/* now quantify & encode AC coefficients */
for (;;) {
UPDATE_CACHE(re, &s->gb);
- GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
+ GET_RL_VLC(level, run, re, &s->gb, rl_vlc,
TEX_VLC_BITS, 2, 0);
if (level >= 64 || i > 63) {
avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
ff_mpv_decode_init(s2, avctx);
- /* we need some permutation to store matrices,
- * until the decoder sets the real permutation. */
- ff_mpv_idct_init(s2);
- ff_mpeg12_common_init(&s->mpeg_enc_ctx);
ff_mpeg12_init_vlcs();
s2->chroma_format = 1;
}
#endif
-static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
- const uint8_t *new_perm)
-{
- uint16_t temp_matrix[64];
- int i;
-
- memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
-
- for (i = 0; i < 64; i++)
- matrix[new_perm[i]] = temp_matrix[old_perm[i]];
-}
-
static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
#if CONFIG_MPEG1_NVDEC_HWACCEL
AV_PIX_FMT_CUDA,
else
pix_fmts = mpeg12_pixfmt_list_444;
- return ff_thread_get_format(avctx, pix_fmts);
+ return ff_get_format(avctx, pix_fmts);
}
/* Call this function when we know all parameters.
{
Mpeg1Context *s1 = avctx->priv_data;
MpegEncContext *s = &s1->mpeg_enc_ctx;
- uint8_t old_permutation[64];
int ret;
if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
(s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
0) {
if (s1->mpeg_enc_ctx_allocated) {
-#if FF_API_FLAG_TRUNCATED
- ParseContext pc = s->parse_context;
- s->parse_context.buffer = 0;
ff_mpv_common_end(s);
- s->parse_context = pc;
-#else
- ff_mpv_common_end(s);
-#endif
s1->mpeg_enc_ctx_allocated = 0;
}
if (ret < 0)
return ret;
- if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
+ if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate &&
+ (s->bit_rate != 0x3FFFF*400)) {
avctx->rc_max_rate = s->bit_rate;
} else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
(s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
// MPEG-1 fps
avctx->framerate = ff_mpeg12_frame_rate_tab[s1->frame_rate_index];
+#if FF_API_TICKS_PER_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
avctx->ticks_per_frame = 1;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
} else { // MPEG-2
ff_mpeg12_frame_rate_tab[s1->frame_rate_index].num * s1->frame_rate_ext.num,
ff_mpeg12_frame_rate_tab[s1->frame_rate_index].den * s1->frame_rate_ext.den,
1 << 30);
+#if FF_API_TICKS_PER_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
avctx->ticks_per_frame = 2;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
switch (s->chroma_format) {
case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
avctx->pix_fmt = mpeg_get_pixelformat(avctx);
- /* Quantization matrices may need reordering
- * if DCT permutation is changed. */
- memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
-
- ff_mpv_idct_init(s);
if ((ret = ff_mpv_common_init(s)) < 0)
return ret;
- quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
- quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
- quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
- quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
-
s1->mpeg_enc_ctx_allocated = 1;
}
return 0;
s->mpeg_f_code[1][0] = f_code;
s->mpeg_f_code[1][1] = f_code;
}
- s->current_picture.f->pict_type = s->pict_type;
- s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
if (avctx->debug & FF_DEBUG_PICT_INFO)
av_log(avctx, AV_LOG_DEBUG,
MpegEncContext *s = &s1->mpeg_enc_ctx;
int horiz_size_ext, vert_size_ext;
int bit_rate_ext;
- AVCPBProperties *cpb_props;
skip_bits(&s->gb, 1); /* profile and level esc*/
s->avctx->profile = get_bits(&s->gb, 3);
bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
s->bit_rate += (bit_rate_ext << 18) * 400LL;
check_marker(s->avctx, &s->gb, "after bit rate extension");
- s1->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
+ s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
s->low_delay = get_bits1(&s->gb);
if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
ff_dlog(s->avctx, "sequence extension\n");
s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
- if (cpb_props = ff_add_cpb_side_data(s->avctx)) {
- cpb_props->buffer_size = s1->rc_buffer_size;
- if (s->bit_rate != 0x3FFFF*400)
- cpb_props->max_bitrate = s->bit_rate;
- }
-
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_DEBUG,
"profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
- s1->rc_buffer_size, s->bit_rate);
+ s->avctx->rc_buffer_size, s->bit_rate);
}
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
s->pict_type = AV_PICTURE_TYPE_P;
} else
s->pict_type = AV_PICTURE_TYPE_B;
- s->current_picture.f->pict_type = s->pict_type;
- s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
}
s->intra_dc_precision = get_bits(&s->gb, 2);
}
if (s->avctx->hwaccel) {
- if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
+ if ((ret = FF_HW_SIMPLE_CALL(s->avctx, end_frame)) < 0) {
av_log(avctx, AV_LOG_ERROR,
"hardware accelerator failed to decode first field\n");
return ret;
}
if (avctx->hwaccel) {
- if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
+ if ((ret = FF_HW_CALL(avctx, start_frame, buf, buf_size)) < 0)
return ret;
}
av_assert0(mb_y < s->mb_height);
- init_get_bits(&s->gb, *buf, buf_size * 8);
+ ret = init_get_bits8(&s->gb, *buf, buf_size);
+ if (ret < 0)
+ return ret;
+
if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
skip_bits(&s->gb, 3);
return AVERROR_INVALIDDATA;
}
- if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
+ if (avctx->hwaccel) {
const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
int start_code = -1;
buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
if (buf_end < *buf + buf_size)
buf_end -= 4;
s->mb_y = mb_y;
- if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
+ if (FF_HW_CALL(avctx, decode_slice, buf_start, buf_end - buf_start) < 0)
return DECODE_SLICE_ERROR;
*buf = buf_end;
return DECODE_SLICE_OK;
return ret;
// Note motion_val is normally NULL unless we want to extract the MVs.
- if (s->current_picture.motion_val[0] && !s->encoding) {
+ if (s->current_picture.motion_val[0]) {
const int wrap = s->b8_stride;
int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
return 0;
if (s->avctx->hwaccel) {
- int ret = s->avctx->hwaccel->end_frame(s->avctx);
+ int ret = FF_HW_SIMPLE_CALL(s->avctx, end_frame);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
"hardware accelerator failed to decode picture\n");
if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
/* end of image */
- ff_er_frame_end(&s->er);
+ ff_er_frame_end(&s->er, NULL);
ff_mpv_frame_end(s);
int width, height;
int i, v, j;
- init_get_bits(&s->gb, buf, buf_size * 8);
+ int ret = init_get_bits8(&s->gb, buf, buf_size);
+ if (ret < 0)
+ return ret;
width = get_bits(&s->gb, 12);
height = get_bits(&s->gb, 12);
return AVERROR_INVALIDDATA;
}
- s1->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
+ s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
skip_bits(&s->gb, 1);
/* get matrix */
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
- s1->rc_buffer_size, s->bit_rate, s1->aspect_ratio_info);
+ s->avctx->rc_buffer_size, s->bit_rate, s1->aspect_ratio_info);
return 0;
}
avctx->pix_fmt = mpeg_get_pixelformat(avctx);
- ff_mpv_idct_init(s);
if ((ret = ff_mpv_common_init(s)) < 0)
return ret;
s1->mpeg_enc_ctx_allocated = 1;
int cc_count = 0;
int i, ret;
- init_get_bits8(&gb, p + 2, buf_size - 2);
+ ret = init_get_bits8(&gb, p + 2, buf_size - 2);
+ if (ret < 0)
+ return ret;
cc_count = get_bits(&gb, 5);
if (cc_count > 0) {
int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
}
}
-static void mpeg_decode_gop(AVCodecContext *avctx,
+static int mpeg_decode_gop(AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
Mpeg1Context *s1 = avctx->priv_data;
int broken_link;
int64_t tc;
- init_get_bits(&s->gb, buf, buf_size * 8);
+ int ret = init_get_bits8(&s->gb, buf, buf_size);
+ if (ret < 0)
+ return ret;
tc = s1->timecode_frame_start = get_bits(&s->gb, 25);
"GOP (%s) closed_gop=%d broken_link=%d\n",
tcbuf, s1->closed_gop, broken_link);
}
+
+ return 0;
}
static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
return AVERROR_INVALIDDATA;
-#if FF_API_FLAG_TRUNCATED
- return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
-#else
return FFMAX(0, buf_ptr - buf);
-#endif
}
input_size = buf_end - buf_ptr;
}
picture_start_code_seen = 1;
+ if (buf == avctx->extradata && avctx->codec_tag == AV_RL32("AVmp")) {
+ av_log(avctx, AV_LOG_WARNING, "ignoring picture start code in AVmp extradata\n");
+ break;
+ }
+
if (s2->width <= 0 || s2->height <= 0) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
s2->width, s2->height);
}
break;
case EXT_START_CODE:
- init_get_bits(&s2->gb, buf_ptr, input_size * 8);
+ ret = init_get_bits8(&s2->gb, buf_ptr, input_size);
+ if (ret < 0)
+ return ret;
switch (get_bits(&s2->gb, 4)) {
case 0x1:
case GOP_START_CODE:
if (last_code == 0) {
s2->first_field = 0;
- mpeg_decode_gop(avctx, buf_ptr, input_size);
+ ret = mpeg_decode_gop(avctx, buf_ptr, input_size);
+ if (ret < 0)
+ return ret;
s->sync = 1;
} else {
av_log(avctx, AV_LOG_ERROR,
if (ret < 0)
return ret;
}
- init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
+ ret = init_get_bits8(&thread_context->gb, buf_ptr, input_size);
+ if (ret < 0)
+ return ret;
s->slice_count++;
}
buf_ptr += 2; // FIXME add minimum number of bytes per slice
return buf_size;
}
-#if FF_API_FLAG_TRUNCATED
- if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
- int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
- buf_size, NULL);
-
- if (ff_combine_frame(&s2->parse_context, next,
- (const uint8_t **) &buf, &buf_size) < 0)
- return buf_size;
- }
-#endif
-
- s2->codec_tag = ff_toupper4(avctx->codec_tag);
if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
|| s2->codec_tag == AV_RL32("BW10")
))
s->sync = 0;
s->closed_gop = 0;
+ av_buffer_unref(&s->a53_buf_ref);
ff_mpeg_flush(avctx);
}
const FFCodec ff_mpeg1video_decoder = {
.p.name = "mpeg1video",
- .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
+ CODEC_LONG_NAME("MPEG-1 video"),
.p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_MPEG1VIDEO,
.priv_data_size = sizeof(Mpeg1Context),
.close = mpeg_decode_end,
FF_CODEC_DECODE_CB(mpeg_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
-#if FF_API_FLAG_TRUNCATED
- AV_CODEC_CAP_TRUNCATED |
-#endif
AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
- .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
- FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+ .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
.flush = flush,
.p.max_lowres = 3,
- .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context),
+ UPDATE_THREAD_CONTEXT(mpeg_decode_update_thread_context),
.hw_configs = (const AVCodecHWConfigInternal *const []) {
#if CONFIG_MPEG1_NVDEC_HWACCEL
HWACCEL_NVDEC(mpeg1),
const FFCodec ff_mpeg2video_decoder = {
.p.name = "mpeg2video",
- .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
+ CODEC_LONG_NAME("MPEG-2 video"),
.p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_MPEG2VIDEO,
.priv_data_size = sizeof(Mpeg1Context),
.close = mpeg_decode_end,
FF_CODEC_DECODE_CB(mpeg_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
-#if FF_API_FLAG_TRUNCATED
- AV_CODEC_CAP_TRUNCATED |
-#endif
AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
- .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
- FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+ .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
.flush = flush,
.p.max_lowres = 3,
.p.profiles = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles),
//legacy decoder
const FFCodec ff_mpegvideo_decoder = {
.p.name = "mpegvideo",
- .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
+ CODEC_LONG_NAME("MPEG-1 video"),
.p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_MPEG2VIDEO,
.priv_data_size = sizeof(Mpeg1Context),
.close = mpeg_decode_end,
FF_CODEC_DECODE_CB(mpeg_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
-#if FF_API_FLAG_TRUNCATED
- AV_CODEC_CAP_TRUNCATED |
-#endif
AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
- .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
- FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+ .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
.flush = flush,
.p.max_lowres = 3,
};
GetBitContext *gb = &m->gb;
int ret;
+ // Check for minimal intra MB size (considering mb header, luma & chroma dc VLC, ac EOB VLC)
+ if (avpkt->size*8LL < (avctx->width+15)/16 * ((avctx->height+15)/16) * (2 + 3*4 + 2*2 + 2*6))
+ return AVERROR_INVALIDDATA;
+
ret = ff_get_buffer(avctx, frame, 0);
if (ret < 0)
return ret;
return AVERROR_INVALIDDATA;
frame->pict_type = AV_PICTURE_TYPE_I;
- frame->key_frame = 1;
+ frame->flags |= AV_FRAME_FLAG_KEY;
*got_frame = 1;
return avpkt->size;
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
ff_mpv_decode_init(m, avctx);
- ff_mpv_idct_init(m);
- ff_mpeg12_common_init(m);
ff_mpeg12_init_vlcs();
for (int i = 0; i < 64; i++) {
const FFCodec ff_ipu_decoder = {
.p.name = "ipu",
- .p.long_name = NULL_IF_CONFIG_SMALL("IPU Video"),
+ CODEC_LONG_NAME("IPU Video"),
.p.type = AVMEDIA_TYPE_VIDEO,
.p.id = AV_CODEC_ID_IPU,
.priv_data_size = sizeof(IPUContext),
FF_CODEC_DECODE_CB(ipu_decode_frame),
.close = ipu_decode_end,
.p.capabilities = AV_CODEC_CAP_DR1,
- .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
};
projects / platform / upstream / ffmpeg.git / blobdiff