FFmpeg: libavcodec/mpeg_er.c Source File

FFmpeg

[フレーム]

libavcodec

mpeg_er.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

4 * FFmpeg is free software; you can redistribute it and/or

5 * modify it under the terms of the GNU Lesser General Public

6 * License as published by the Free Software Foundation; either

7 * version 2.1 of the License, or (at your option) any later version.

8 *

9 * FFmpeg is distributed in the hope that it will be useful,

10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

12 * Lesser General Public License for more details.

13 *

14 * You should have received a copy of the GNU Lesser General Public

15 * License along with FFmpeg; if not, write to the Free Software

16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

17 */

19 #include "libavutil/avassert.h"

20 #include "libavutil/mem.h"

21 #include "error_resilience.h"

22 #include "mpegvideo.h"

23 #include "mpegvideodec.h"

24 #include "mpeg_er.h"

26 static void set_erpic(ERPicture *dst, const MPVPicture *src)

27 {

28 int i;

30 memset(dst, 0, sizeof(*dst));

31 if (!src)

32 return;

34 dst->f = src->f;

35 dst->progress = &src->progress;

37 for (i = 0; i < 2; i++) {

38 dst->motion_val[i] = src->motion_val[i];

39 dst->ref_index[i] = src->ref_index[i];

40 }

42 dst->mb_type = src->mb_type;

43 dst->field_picture = src->field_picture;

44 }

46 void ff_mpeg_er_frame_start(MpegEncContext *s)

47 {

48 ERContext *er = &s->er;

50 set_erpic(&er->cur_pic, s->cur_pic.ptr);

51 set_erpic(&er->next_pic, s->next_pic.ptr);

52 set_erpic(&er->last_pic, s->last_pic.ptr);

54 er->quarter_sample = s->quarter_sample;

56 ff_er_frame_start(er);

57 }

59 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,

60 int (*mv)[2][4][2], int mb_x, int mb_y,

61 int mb_intra, int mb_skipped)

62 {

63 MpegEncContext *s = opaque;

65 av_assert1(!mb_intra);

67 s->mv_dir = mv_dir;

68 s->mv_type = mv_type;

69 s->mb_intra = mb_intra;

70 s->mb_skipped = mb_skipped;

71 s->mb_x = mb_x;

72 s->mb_y = mb_y;

73 s->mcsel = 0;

74 memcpy(s->mv, mv, sizeof(*mv));

76 // The following disables unquantizing and the IDCT.

77 for (size_t i = 0; i < FF_ARRAY_ELEMS(s->block_last_index); i++)

78 s->block_last_index[i] = -1;

80 s->dest[0] = s->cur_pic.data[0] +

81 s->mb_y * 16 * s->linesize +

82 s->mb_x * 16;

83 s->dest[1] = s->cur_pic.data[1] +

84 s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize +

85 s->mb_x * (16 >> s->chroma_x_shift);

86 s->dest[2] = s->cur_pic.data[2] +

87 s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize +

88 s->mb_x * (16 >> s->chroma_x_shift);

90 if (ref)

91 av_log(s->avctx, AV_LOG_DEBUG,

92 "Interlaced error concealment is not fully implemented\n");

93 ff_mpv_reconstruct_mb(s, NULL);

94 }

96 av_cold int ff_mpeg_er_init(MpegEncContext *s)

97 {

98 ERContext *er = &s->er;

99 int mb_array_size = s->mb_height * s->mb_stride;

100

101 er->avctx = s->avctx;

102

103 er->mb_index2xy = s->mb_index2xy;

104 er->mb_num = s->mb_num;

105 er->mb_width = s->mb_width;

106 er->mb_height = s->mb_height;

107 er->mb_stride = s->mb_stride;

108 er->b8_stride = s->b8_stride;

109

110 er->dc_val[0] = s->dc_val;

111 er->dc_val[1] = er->dc_val[0] + s->b8_stride * 2 * s->buffer_pools.alloc_mb_height + s->mb_stride;

112 er->dc_val[2] = er->dc_val[1] + s->mb_stride * (s->buffer_pools.alloc_mb_height + 1);

113

114 er->er_temp_buffer = av_malloc(s->mb_height * s->mb_stride * (4*sizeof(int) + 1));

115 er->error_status_table = av_mallocz(mb_array_size);

116 if (!er->er_temp_buffer || !er->error_status_table)

117 goto fail;

118

119 er->mbskip_table = s->mbskip_table;

120 er->mbintra_table = s->mbintra_table;

121

122 er->decode_mb = mpeg_er_decode_mb;

123 er->opaque = s;

124

125 return 0;

126 fail:

127 av_freep(&er->er_temp_buffer);

128 av_freep(&er->error_status_table);

129 return AVERROR(ENOMEM);

130 }

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

static const int8_t mv[256][2]

Definition: 4xm.c:81

ERContext::mbintra_table

uint8_t * mbintra_table

Definition: error_resilience.h:73

ERContext::mb_index2xy

int * mb_index2xy

Definition: error_resilience.h:61

ff_er_frame_start

void ff_er_frame_start(ERContext *s)

Definition: error_resilience.c:793

ERContext