Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

avcodec: remove FF_API_FLAG_TRUNCATED

Browse Source 
Signed-off-by: James Almer <jamrial@gmail.com>
release/6.0
James Almer 2 years ago committed by Anton Khirnov
parent 5f9e848e68
commit 3ceffe7839
19 changed files with 1 additions and 293 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      libavcodec/avcodec.h
  2. 6
      libavcodec/codec.h
  3. 4
      libavcodec/decode.c
  4. 11
      libavcodec/h263_parser.c
  5. 29
      libavcodec/h263_parser.h
  6. 42
      libavcodec/h263dec.c
  7. 66
      libavcodec/mpeg12.c
  8. 9
      libavcodec/mpeg12.h
  9. 31
      libavcodec/mpeg12dec.c
  10. 12
      libavcodec/mpeg4video_parser.c
  11. 34
      libavcodec/mpeg4video_parser.h
  12. 3
      libavcodec/mpeg4videodec.c
  13. 9
      libavcodec/mpegvideo.c
  14. 7
      libavcodec/mpegvideo.h
  15. 8
      libavcodec/mpegvideo_dec.c
  16. 7
      libavcodec/mpegvideo_parser.c
  17. 3
      libavcodec/options_table.h
  18. 3
      libavcodec/pthread.c
  19. 1
      libavcodec/version_major.h

9
libavcodec/avcodec.h
Unescape View File

@ -303,15 +303,6 @@ typedef struct RcOverride{
* error[?] variables will be set during encoding. * error[?] variables will be set during encoding.
*/ */
#define AV_CODEC_FLAG_PSNR (1 << 15) #define AV_CODEC_FLAG_PSNR (1 << 15)
#if FF_API_FLAG_TRUNCATED
/**
* Input bitstream might be truncated at a random location
* instead of only at frame boundaries.
*
* @deprecated use codec parsers for packetizing input
*/
#define AV_CODEC_FLAG_TRUNCATED (1 << 16)
#endif
/** /**
* Use interlaced DCT. * Use interlaced DCT.
*/ */

6
libavcodec/codec.h
Unescape View File

@ -50,12 +50,6 @@
* avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer. * avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer.
*/ */
#define AV_CODEC_CAP_DR1 (1 << 1) #define AV_CODEC_CAP_DR1 (1 << 1)
#if FF_API_FLAG_TRUNCATED
/**
* @deprecated Use parsers to always send proper frames.
*/
#define AV_CODEC_CAP_TRUNCATED (1 << 3)
#endif
/** /**
* Encoder or decoder requires flushing with NULL input at the end in order to * Encoder or decoder requires flushing with NULL input at the end in order to
* give the complete and correct output. * give the complete and correct output.

4
libavcodec/decode.c
Unescape View File

@ -427,11 +427,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
if (!got_frame) if (!got_frame)
av_frame_unref(frame); av_frame_unref(frame);
#if FF_API_FLAG_TRUNCATED
if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
#else
if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO) if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
#endif
ret = pkt->size; ret = pkt->size;
/* do not stop draining when actual_got_frame != 0 or ret < 0 */ /* do not stop draining when actual_got_frame != 0 or ret < 0 */

11
libavcodec/h263_parser.c
Unescape View File

@ -25,16 +25,9 @@
*/ */
#include "parser.h" #include "parser.h"
#if FF_API_FLAG_TRUNCATED
/* Nuke this header when removing FF_API_FLAG_TRUNCATED */
#include "h263_parser.h"
int ff_h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
#else
static int h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size) static int h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
{ {
#endif
int vop_found, i; int vop_found, i;
uint32_t state; uint32_t state;
@ -80,11 +73,7 @@ static int h263_parse(AVCodecParserContext *s,
if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) { if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
next = buf_size; next = buf_size;
} else { } else {
#if FF_API_FLAG_TRUNCATED
next= ff_h263_find_frame_end(pc, buf, buf_size);
#else
next = h263_find_frame_end(pc, buf, buf_size); next = h263_find_frame_end(pc, buf, buf_size);
#endif
if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) { if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
*poutbuf = NULL; *poutbuf = NULL;

29
libavcodec/h263_parser.h
Unescape View File

@ -1,29 +0,0 @@
/*
* H.263 parser
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_H263_PARSER_H
#define AVCODEC_H263_PARSER_H
#include "parser.h"
int ff_h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size);
#endif /* AVCODEC_H263_PARSER_H */

42
libavcodec/h263dec.c
Unescape View File

@ -36,17 +36,11 @@
#include "flvdec.h" #include "flvdec.h"
#include "h263.h" #include "h263.h"
#include "h263dec.h" #include "h263dec.h"
#if FF_API_FLAG_TRUNCATED
#include "h263_parser.h"
#endif
#include "hwconfig.h" #include "hwconfig.h"
#include "mpeg_er.h" #include "mpeg_er.h"
#include "mpeg4video.h" #include "mpeg4video.h"
#include "mpeg4videodec.h" #include "mpeg4videodec.h"
#include "mpeg4videodefs.h" #include "mpeg4videodefs.h"
#if FF_API_FLAG_TRUNCATED
#include "mpeg4video_parser.h"
#endif
#include "mpegutils.h" #include "mpegutils.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#include "mpegvideodec.h" #include "mpegvideodec.h"
@ -163,14 +157,6 @@ static int get_consumed_bytes(MpegEncContext *s, int buf_size)
/* We would have to scan through the whole buf to handle the weird /* We would have to scan through the whole buf to handle the weird
* reordering ... */ * reordering ... */
return buf_size; return buf_size;
#if FF_API_FLAG_TRUNCATED
} else if (s->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
pos -= s->parse_context.last_index;
// padding is not really read so this might be -1
if (pos < 0)
pos = 0;
return pos;
#endif
} else { } else {
// avoid infinite loops (maybe not needed...) // avoid infinite loops (maybe not needed...)
if (pos == 0) if (pos == 0)
@ -448,28 +434,6 @@ int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,
return 0; return 0;
} }
#if FF_API_FLAG_TRUNCATED
if (s->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
int next;
if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) {
next = ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);
} else if (CONFIG_H263_DECODER && s->codec_id == AV_CODEC_ID_H263) {
next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
} else if (CONFIG_H263P_DECODER && s->codec_id == AV_CODEC_ID_H263P) {
next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
} else {
av_log(s->avctx, AV_LOG_ERROR,
"this codec does not support truncated bitstreams\n");
return AVERROR(ENOSYS);
}
if (ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf,
&buf_size) < 0)
return buf_size;
}
#endif
retry: retry:
if (s->divx_packed && s->bitstream_buffer_size) { if (s->divx_packed && s->bitstream_buffer_size) {
int i; int i;
@ -749,9 +713,6 @@ const FFCodec ff_h263_decoder = {
.close = ff_h263_decode_end, .close = ff_h263_decode_end,
FF_CODEC_DECODE_CB(ff_h263_decode_frame), FF_CODEC_DECODE_CB(ff_h263_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | .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_DELAY,
.caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
.flush = ff_mpeg_flush, .flush = ff_mpeg_flush,
@ -770,9 +731,6 @@ const FFCodec ff_h263p_decoder = {
.close = ff_h263_decode_end, .close = ff_h263_decode_end,
FF_CODEC_DECODE_CB(ff_h263_decode_frame), FF_CODEC_DECODE_CB(ff_h263_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | .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_DELAY,
.caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
.flush = ff_mpeg_flush, .flush = ff_mpeg_flush,

66
libavcodec/mpeg12.c
Unescape View File

@ -167,72 +167,6 @@ av_cold void ff_mpeg12_init_vlcs(void)
ff_thread_once(&init_static_once, mpeg12_init_vlcs); ff_thread_once(&init_static_once, mpeg12_init_vlcs);
} }
#if FF_API_FLAG_TRUNCATED
/**
* Find the end of the current frame in the bitstream.
* @return the position of the first byte of the next frame, or -1
*/
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s)
{
int i;
uint32_t state = pc->state;
/* EOF considered as end of frame */
if (buf_size == 0)
return 0;
/*
0 frame start -> 1/4
1 first_SEQEXT -> 0/2
2 first field start -> 3/0
3 second_SEQEXT -> 2/0
4 searching end
*/
for (i = 0; i < buf_size; i++) {
av_assert1(pc->frame_start_found >= 0 && pc->frame_start_found <= 4);
if (pc->frame_start_found & 1) {
if (state == EXT_START_CODE && (buf[i] & 0xF0) != 0x80)
pc->frame_start_found--;
else if (state == EXT_START_CODE + 2) {
if ((buf[i] & 3) == 3)
pc->frame_start_found = 0;
else
pc->frame_start_found = (pc->frame_start_found + 1) & 3;
}
state++;
} else {
i = avpriv_find_start_code(buf + i, buf + buf_size, &state) - buf - 1;
if (pc->frame_start_found == 0 && state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE) {
i++;
pc->frame_start_found = 4;
}
if (state == SEQ_END_CODE) {
pc->frame_start_found = 0;
pc->state=-1;
return i+1;
}
if (pc->frame_start_found == 2 && state == SEQ_START_CODE)
pc->frame_start_found = 0;
if (pc->frame_start_found < 4 && state == EXT_START_CODE)
pc->frame_start_found++;
if (pc->frame_start_found == 4 && (state & 0xFFFFFF00) == 0x100) {
if (state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE) {
pc->frame_start_found = 0;
pc->state = -1;
return i - 3;
}
}
if (pc->frame_start_found == 0 && s && state == PICTURE_START_CODE) {
ff_fetch_timestamp(s, i - 3, 1, i > 3);
}
}
}
pc->state = state;
return END_NOT_FOUND;
}
#endif
#define MAX_INDEX (64 - 1) #define MAX_INDEX (64 - 1)
int ff_mpeg1_decode_block_intra(GetBitContext *gb, int ff_mpeg1_decode_block_intra(GetBitContext *gb,

9
libavcodec/mpeg12.h
Unescape View File

@ -34,15 +34,6 @@
#define EXT_START_CODE 0x000001b5 #define EXT_START_CODE 0x000001b5
#define USER_START_CODE 0x000001b2 #define USER_START_CODE 0x000001b2
#include "version_major.h"
#if FF_API_FLAG_TRUNCATED
#include <stdint.h>
struct ParseContext;
struct AVCodecParserContext;
int ff_mpeg1_find_frame_end(struct ParseContext *pc, const uint8_t *buf, int buf_size, struct AVCodecParserContext *s);
#endif
void ff_mpeg12_find_best_frame_rate(AVRational frame_rate, void ff_mpeg12_find_best_frame_rate(AVRational frame_rate,
int *code, int *ext_n, int *ext_d, int *code, int *ext_n, int *ext_d,
int nonstandard); int nonstandard);

31
libavcodec/mpeg12dec.c
Unescape View File

@ -1239,14 +1239,7 @@ static int mpeg_decode_postinit(AVCodecContext *avctx)
(s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) || (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
0) { 0) {
if (s1->mpeg_enc_ctx_allocated) { 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); ff_mpv_common_end(s);
s->parse_context = pc;
#else
ff_mpv_common_end(s);
#endif
s1->mpeg_enc_ctx_allocated = 0; s1->mpeg_enc_ctx_allocated = 0;
} }
@ -2482,11 +2475,7 @@ static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count) if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
return AVERROR_INVALIDDATA; 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); return FFMAX(0, buf_ptr - buf);
#endif
} }
input_size = buf_end - buf_ptr; input_size = buf_end - buf_ptr;
@ -2799,17 +2788,6 @@ static int mpeg_decode_frame(AVCodecContext *avctx, AVFrame *picture,
return buf_size; 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
if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2") if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
|| s2->codec_tag == AV_RL32("BW10") || s2->codec_tag == AV_RL32("BW10")
)) ))
@ -2886,9 +2864,6 @@ const FFCodec ff_mpeg1video_decoder = {
.close = mpeg_decode_end, .close = mpeg_decode_end,
FF_CODEC_DECODE_CB(mpeg_decode_frame), FF_CODEC_DECODE_CB(mpeg_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | .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, AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
.caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
.flush = flush, .flush = flush,
@ -2918,9 +2893,6 @@ const FFCodec ff_mpeg2video_decoder = {
.close = mpeg_decode_end, .close = mpeg_decode_end,
FF_CODEC_DECODE_CB(mpeg_decode_frame), FF_CODEC_DECODE_CB(mpeg_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | .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, AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
.caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
.flush = flush, .flush = flush,
@ -2963,9 +2935,6 @@ const FFCodec ff_mpegvideo_decoder = {
.close = mpeg_decode_end, .close = mpeg_decode_end,
FF_CODEC_DECODE_CB(mpeg_decode_frame), FF_CODEC_DECODE_CB(mpeg_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | .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, AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
.caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
.flush = flush, .flush = flush,

12
libavcodec/mpeg4video_parser.c
Unescape View File

@ -27,10 +27,6 @@
#include "mpegvideo.h" #include "mpegvideo.h"
#include "mpeg4videodec.h" #include "mpeg4videodec.h"
#include "mpeg4videodefs.h" #include "mpeg4videodefs.h"
#if FF_API_FLAG_TRUNCATED
/* Nuke this header when removing FF_API_FLAG_TRUNCATED */
#include "mpeg4video_parser.h"
#endif
struct Mp4vParseContext { struct Mp4vParseContext {
ParseContext pc; ParseContext pc;
@ -38,15 +34,11 @@ struct Mp4vParseContext {
int first_picture; int first_picture;
}; };
#if FF_API_FLAG_TRUNCATED
int ff_mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
#else
/** /**
* Find the end of the current frame in the bitstream. * Find the end of the current frame in the bitstream.
* @return the position of the first byte of the next frame, or -1 * @return the position of the first byte of the next frame, or -1
*/ */
static int mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size) static int mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
#endif
{ {
int vop_found, i; int vop_found, i;
uint32_t state; uint32_t state;
@ -148,11 +140,7 @@ static int mpeg4video_parse(AVCodecParserContext *s,
if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) { if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
next = buf_size; next = buf_size;
} else { } else {
#if FF_API_FLAG_TRUNCATED
next = ff_mpeg4_find_frame_end(pc, buf, buf_size);
#else
next = mpeg4_find_frame_end(pc, buf, buf_size); next = mpeg4_find_frame_end(pc, buf, buf_size);
#endif
if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) { if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
*poutbuf = NULL; *poutbuf = NULL;

34
libavcodec/mpeg4video_parser.h
Unescape View File

@ -1,34 +0,0 @@
/*
* MPEG-4 video parser prototypes
* Copyright (c) 2003 Fabrice Bellard
* Copyright (c) 2003 Michael Niedermayer
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_MPEG4VIDEO_PARSER_H
#define AVCODEC_MPEG4VIDEO_PARSER_H
#include "parser.h"
/**
* Find the end of the current frame in the bitstream.
* @return the position of the first byte of the next frame, or -1
*/
int ff_mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size);
#endif /* AVCODEC_MPEG4VIDEO_PARSER_H */

3
libavcodec/mpeg4videodec.c
Unescape View File

@ -3859,9 +3859,6 @@ const FFCodec ff_mpeg4_decoder = {
.close = ff_h263_decode_end, .close = ff_h263_decode_end,
FF_CODEC_DECODE_CB(ff_h263_decode_frame), FF_CODEC_DECODE_CB(ff_h263_decode_frame),
.p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | .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_FRAME_THREADS, AV_CODEC_CAP_DELAY | AV_CODEC_CAP_FRAME_THREADS,
.caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
FF_CODEC_CAP_ALLOCATE_PROGRESS, FF_CODEC_CAP_ALLOCATE_PROGRESS,

9
libavcodec/mpegvideo.c
Unescape View File

@ -738,10 +738,6 @@ av_cold int ff_mpv_common_init(MpegEncContext *s)
nb_slices = max_slices; nb_slices = max_slices;
} }
#if FF_API_FLAG_TRUNCATED
s->parse_context.state = -1;
#endif
s->context_initialized = 1; s->context_initialized = 1;
memset(s->thread_context, 0, sizeof(s->thread_context)); memset(s->thread_context, 0, sizeof(s->thread_context));
s->thread_context[0] = s; s->thread_context[0] = s;
@ -791,11 +787,6 @@ void ff_mpv_common_end(MpegEncContext *s)
if (s->slice_context_count > 1) if (s->slice_context_count > 1)
s->slice_context_count = 1; s->slice_context_count = 1;
#if FF_API_FLAG_TRUNCATED
av_freep(&s->parse_context.buffer);
s->parse_context.buffer_size = 0;
#endif
av_freep(&s->bitstream_buffer); av_freep(&s->bitstream_buffer);
s->allocated_bitstream_buffer_size = 0; s->allocated_bitstream_buffer_size = 0;

7
libavcodec/mpegvideo.h
Unescape View File

@ -44,9 +44,6 @@
#include "pixblockdsp.h" #include "pixblockdsp.h"
#include "put_bits.h" #include "put_bits.h"
#include "ratecontrol.h" #include "ratecontrol.h"
#if FF_API_FLAG_TRUNCATED
#include "parser.h"
#endif
#include "mpegutils.h" #include "mpegutils.h"
#include "qpeldsp.h" #include "qpeldsp.h"
#include "videodsp.h" #include "videodsp.h"
@ -353,10 +350,6 @@ typedef struct MpegEncContext {
GetBitContext last_resync_gb; ///< used to search for the next resync marker GetBitContext last_resync_gb; ///< used to search for the next resync marker
int mb_num_left; ///< number of MBs left in this video packet (for partitioned Slices only) int mb_num_left; ///< number of MBs left in this video packet (for partitioned Slices only)
#if FF_API_FLAG_TRUNCATED
ParseContext parse_context;
#endif
/* H.263 specific */ /* H.263 specific */
int gob_index; int gob_index;
int obmc; ///< overlapped block motion compensation int obmc; ///< overlapped block motion compensation

8
libavcodec/mpegvideo_dec.c
Unescape View File

@ -554,14 +554,6 @@ void ff_mpeg_flush(AVCodecContext *avctx)
s->mb_x = s->mb_y = 0; s->mb_x = s->mb_y = 0;
#if FF_API_FLAG_TRUNCATED
s->parse_context.state = -1;
s->parse_context.frame_start_found = 0;
s->parse_context.overread = 0;
s->parse_context.overread_index = 0;
s->parse_context.index = 0;
s->parse_context.last_index = 0;
#endif
s->bitstream_buffer_size = 0; s->bitstream_buffer_size = 0;
s->pp_time = 0; s->pp_time = 0;
} }

7
libavcodec/mpegvideo_parser.c
Unescape View File

@ -20,6 +20,7 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "libavutil/avassert.h"
#include "decode.h" #include "decode.h"
#include "parser.h" #include "parser.h"
#include "mpeg12.h" #include "mpeg12.h"
@ -33,7 +34,6 @@ struct MpvParseContext {
int width, height; int width, height;
}; };
#if !FF_API_FLAG_TRUNCATED
/** /**
* Find the end of the current frame in the bitstream. * Find the end of the current frame in the bitstream.
* @return the position of the first byte of the next frame, or -1 * @return the position of the first byte of the next frame, or -1
@ -98,7 +98,6 @@ static int mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf,
pc->state = state; pc->state = state;
return END_NOT_FOUND; return END_NOT_FOUND;
} }
#endif
static void mpegvideo_extract_headers(AVCodecParserContext *s, static void mpegvideo_extract_headers(AVCodecParserContext *s,
AVCodecContext *avctx, AVCodecContext *avctx,
@ -255,11 +254,7 @@ static int mpegvideo_parse(AVCodecParserContext *s,
if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){ if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
next= buf_size; next= buf_size;
}else{ }else{
#if FF_API_FLAG_TRUNCATED
next= ff_mpeg1_find_frame_end(pc, buf, buf_size, s);
#else
next = mpeg1_find_frame_end(pc, buf, buf_size, s); next = mpeg1_find_frame_end(pc, buf, buf_size, s);
#endif
if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) { if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
*poutbuf = NULL; *poutbuf = NULL;

3
libavcodec/options_table.h
Unescape View File

@ -64,9 +64,6 @@ static const AVOption avcodec_options[] = {
{"pass2", "use internal 2-pass ratecontrol in second pass mode", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_PASS2 }, INT_MIN, INT_MAX, 0, "flags"}, {"pass2", "use internal 2-pass ratecontrol in second pass mode", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_PASS2 }, INT_MIN, INT_MAX, 0, "flags"},
{"gray", "only decode/encode grayscale", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_GRAY }, INT_MIN, INT_MAX, V|E|D, "flags"}, {"gray", "only decode/encode grayscale", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_GRAY }, INT_MIN, INT_MAX, V|E|D, "flags"},
{"psnr", "error[?] variables will be set during encoding", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_PSNR }, INT_MIN, INT_MAX, V|E, "flags"}, {"psnr", "error[?] variables will be set during encoding", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_PSNR }, INT_MIN, INT_MAX, V|E, "flags"},
#if FF_API_FLAG_TRUNCATED
{"truncated", "(Deprecated, use parsers instead.) Input bitstream might be randomly truncated", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_TRUNCATED }, INT_MIN, INT_MAX, V|D | AV_OPT_FLAG_DEPRECATED, "flags"},
#endif
{"ildct", "use interlaced DCT", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_INTERLACED_DCT }, INT_MIN, INT_MAX, V|E, "flags"}, {"ildct", "use interlaced DCT", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_INTERLACED_DCT }, INT_MIN, INT_MAX, V|E, "flags"},
{"low_delay", "force low delay", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_LOW_DELAY }, INT_MIN, INT_MAX, V|D|E, "flags"}, {"low_delay", "force low delay", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_LOW_DELAY }, INT_MIN, INT_MAX, V|D|E, "flags"},
{"global_header", "place global headers in extradata instead of every keyframe", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_GLOBAL_HEADER }, INT_MIN, INT_MAX, V|A|E, "flags"}, {"global_header", "place global headers in extradata instead of every keyframe", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_GLOBAL_HEADER }, INT_MIN, INT_MAX, V|A|E, "flags"},

3
libavcodec/pthread.c
Unescape View File

@ -48,9 +48,6 @@
static void validate_thread_parameters(AVCodecContext *avctx) static void validate_thread_parameters(AVCodecContext *avctx)
{ {
int frame_threading_supported = (avctx->codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) int frame_threading_supported = (avctx->codec->capabilities & AV_CODEC_CAP_FRAME_THREADS)
#if FF_API_FLAG_TRUNCATED
&& !(avctx->flags & AV_CODEC_FLAG_TRUNCATED)
#endif
&& !(avctx->flags & AV_CODEC_FLAG_LOW_DELAY) && !(avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
&& !(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS); && !(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS);
if (avctx->thread_count == 1) { if (avctx->thread_count == 1) {

1
libavcodec/version_major.h
Unescape View File

@ -38,7 +38,6 @@
*/ */
#define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 60) #define FF_API_INIT_PACKET (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_FLAG_TRUNCATED (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_SUB_TEXT_FORMAT (LIBAVCODEC_VERSION_MAJOR < 60) #define FF_API_SUB_TEXT_FORMAT (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_IDCT_NONE (LIBAVCODEC_VERSION_MAJOR < 60) #define FF_API_IDCT_NONE (LIBAVCODEC_VERSION_MAJOR < 60)
#define FF_API_SVTAV1_OPTS (LIBAVCODEC_VERSION_MAJOR < 60) #define FF_API_SVTAV1_OPTS (LIBAVCODEC_VERSION_MAJOR < 60)

Write Preview
Loading…
Cancel
Save