FFmpeg
h264_picture.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... decoder
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * H.264 / AVC / MPEG-4 part10 codec.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/emms.h"
30 #include "error_resilience.h"
31 #include "avcodec.h"
32 #include "h264dec.h"
33 #include "hwaccel_internal.h"
34 #include "mpegutils.h"
35 #include "refstruct.h"
36 #include "thread.h"
37 #include "threadframe.h"
38 
39 void ff_h264_unref_picture(H264Picture *pic)
40 {
41  int off = offsetof(H264Picture, f_grain) + sizeof(pic->f_grain);
42  int i;
43 
44  if (!pic->f || !pic->f->buf[0])
45  return;
46 
47  ff_thread_release_ext_buffer(&pic->tf);
48  av_frame_unref(pic->f_grain);
49  ff_refstruct_unref(&pic->hwaccel_picture_private);
50 
51  av_buffer_unref(&pic->qscale_table_buf);
52  av_buffer_unref(&pic->mb_type_buf);
53  ff_refstruct_unref(&pic->pps);
54  for (i = 0; i < 2; i++) {
55  av_buffer_unref(&pic->motion_val_buf[i]);
56  av_buffer_unref(&pic->ref_index_buf[i]);
57  }
58  av_buffer_unref(&pic->decode_error_flags);
59 
60  memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
61 }
62 
63 static void h264_copy_picture_params(H264Picture *dst, const H264Picture *src)
64 {
65  ff_refstruct_replace(&dst->pps, src->pps);
66 
67  dst->qscale_table = src->qscale_table;
68  dst->mb_type = src->mb_type;
69 
70  for (int i = 0; i < 2; i++) {
71  dst->motion_val[i] = src->motion_val[i];
72  dst->ref_index[i] = src->ref_index[i];
73  }
74 
75  for (int i = 0; i < 2; i++)
76  dst->field_poc[i] = src->field_poc[i];
77 
78  memcpy(dst->ref_poc, src->ref_poc, sizeof(src->ref_poc));
79  memcpy(dst->ref_count, src->ref_count, sizeof(src->ref_count));
80 
81  dst->poc = src->poc;
82  dst->frame_num = src->frame_num;
83  dst->mmco_reset = src->mmco_reset;
84  dst->long_ref = src->long_ref;
85  dst->mbaff = src->mbaff;
86  dst->field_picture = src->field_picture;
87  dst->reference = src->reference;
88  dst->recovered = src->recovered;
89  dst->invalid_gap = src->invalid_gap;
90  dst->sei_recovery_frame_cnt = src->sei_recovery_frame_cnt;
91  dst->mb_width = src->mb_width;
92  dst->mb_height = src->mb_height;
93  dst->mb_stride = src->mb_stride;
94  dst->needs_fg = src->needs_fg;
95 }
96 
97 int ff_h264_ref_picture(H264Picture *dst, const H264Picture *src)
98 {
99  int ret, i;
100 
101  av_assert0(!dst->f->buf[0]);
102  av_assert0(src->f->buf[0]);
103  av_assert0(src->tf.f == src->f);
104 
105  dst->tf.f = dst->f;
106  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
107  if (ret < 0)
108  goto fail;
109 
110  if (src->needs_fg) {
111  ret = av_frame_ref(dst->f_grain, src->f_grain);
112  if (ret < 0)
113  goto fail;
114  }
115 
116  dst->qscale_table_buf = av_buffer_ref(src->qscale_table_buf);
117  dst->mb_type_buf = av_buffer_ref(src->mb_type_buf);
118  if (!dst->qscale_table_buf || !dst->mb_type_buf) {
119  ret = AVERROR(ENOMEM);
120  goto fail;
121  }
122 
123  for (i = 0; i < 2; i++) {
124  dst->motion_val_buf[i] = av_buffer_ref(src->motion_val_buf[i]);
125  dst->ref_index_buf[i] = av_buffer_ref(src->ref_index_buf[i]);
126  if (!dst->motion_val_buf[i] || !dst->ref_index_buf[i]) {
127  ret = AVERROR(ENOMEM);
128  goto fail;
129  }
130  }
131 
132  ff_refstruct_replace(&dst->hwaccel_picture_private,
133  src->hwaccel_picture_private);
134 
135  ret = av_buffer_replace(&dst->decode_error_flags, src->decode_error_flags);
136  if (ret < 0)
137  goto fail;
138 
139  h264_copy_picture_params(dst, src);
140 
141  return 0;
142 fail:
143  ff_h264_unref_picture(dst);
144  return ret;
145 }
146 
147 int ff_h264_replace_picture(H264Picture *dst, const H264Picture *src)
148 {
149  int ret, i;
150 
151  if (!src->f || !src->f->buf[0]) {
152  ff_h264_unref_picture(dst);
153  return 0;
154  }
155 
156  av_assert0(src->tf.f == src->f);
157 
158  dst->tf.f = dst->f;
159  ret = ff_thread_replace_frame(&dst->tf, &src->tf);
160  if (ret < 0)
161  goto fail;
162 
163  if (src->needs_fg) {
164  av_frame_unref(dst->f_grain);
165  ret = av_frame_ref(dst->f_grain, src->f_grain);
166  if (ret < 0)
167  goto fail;
168  }
169 
170  ret = av_buffer_replace(&dst->qscale_table_buf, src->qscale_table_buf);
171  ret |= av_buffer_replace(&dst->mb_type_buf, src->mb_type_buf);
172  if (ret < 0)
173  goto fail;
174 
175  for (i = 0; i < 2; i++) {
176  ret = av_buffer_replace(&dst->motion_val_buf[i], src->motion_val_buf[i]);
177  ret |= av_buffer_replace(&dst->ref_index_buf[i], src->ref_index_buf[i]);
178  if (ret < 0)
179  goto fail;
180  }
181 
182  ff_refstruct_replace(&dst->hwaccel_picture_private,
183  src->hwaccel_picture_private);
184 
185  ret = av_buffer_replace(&dst->decode_error_flags, src->decode_error_flags);
186  if (ret < 0)
187  goto fail;
188 
189  h264_copy_picture_params(dst, src);
190 
191  return 0;
192 fail:
193  ff_h264_unref_picture(dst);
194  return ret;
195 }
196 
197 void ff_h264_set_erpic(ERPicture *dst, const H264Picture *src)
198 {
199 #if CONFIG_ERROR_RESILIENCE
200  int i;
201 
202  memset(dst, 0, sizeof(*dst));
203 
204  if (!src)
205  return;
206 
207  dst->f = src->f;
208  dst->tf = &src->tf;
209 
210  for (i = 0; i < 2; i++) {
211  dst->motion_val[i] = src->motion_val[i];
212  dst->ref_index[i] = src->ref_index[i];
213  }
214 
215  dst->mb_type = src->mb_type;
216  dst->field_picture = src->field_picture;
217 #endif /* CONFIG_ERROR_RESILIENCE */
218 }
219 
220 int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
221 {
222  AVCodecContext *const avctx = h->avctx;
223  H264Picture *cur = h->cur_pic_ptr;
224  int err = 0;
225  h->mb_y = 0;
226 
227  if (in_setup || !(avctx->active_thread_type & FF_THREAD_FRAME)) {
228  if (!h->droppable) {
229  err = ff_h264_execute_ref_pic_marking(h);
230  h->poc.prev_poc_msb = h->poc.poc_msb;
231  h->poc.prev_poc_lsb = h->poc.poc_lsb;
232  }
233  h->poc.prev_frame_num_offset = h->poc.frame_num_offset;
234  h->poc.prev_frame_num = h->poc.frame_num;
235  }
236 
237  if (avctx->hwaccel) {
238  err = FF_HW_SIMPLE_CALL(avctx, end_frame);
239  if (err < 0)
240  av_log(avctx, AV_LOG_ERROR,
241  "hardware accelerator failed to decode picture\n");
242  } else if (!in_setup && cur->needs_fg && (!FIELD_PICTURE(h) || !h->first_field)) {
243  const AVFrameSideData *sd = av_frame_get_side_data(cur->f, AV_FRAME_DATA_FILM_GRAIN_PARAMS);
244 
245  err = AVERROR_INVALIDDATA;
246  if (sd) // a decoding error may have happened before the side data could be allocated
247  err = ff_h274_apply_film_grain(cur->f_grain, cur->f, &h->h274db,
248  (AVFilmGrainParams *) sd->data);
249  if (err < 0) {
250  av_log(h->avctx, AV_LOG_WARNING, "Failed synthesizing film "
251  "grain, ignoring: %s\n", av_err2str(err));
252  cur->needs_fg = 0;
253  err = 0;
254  }
255  }
256 
257  if (!in_setup && !h->droppable)
258  ff_thread_report_progress(&cur->tf, INT_MAX,
259  h->picture_structure == PICT_BOTTOM_FIELD);
260  emms_c();
261 
262  h->current_slice = 0;
263 
264  return err;
265 }
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1435
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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
H264Picture::poc
int poc
frame POC
Definition: h264dec.h:128
H264Picture::f
AVFrame * f
Definition: h264dec.h:107
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:824
ff_h264_ref_picture
int ff_h264_ref_picture(H264Picture *dst, const H264Picture *src)
Definition: h264_picture.c:97
H264Picture::ref_count
int ref_count[2][2]
number of entries in ref_poc (FIXME need per slice)
Definition: h264dec.h:136
H264Picture::ref_index
int8_t * ref_index[2]
Definition: h264dec.h:125
ERPicture::ref_index
int8_t * ref_index[2]
Definition: error_resilience.h:46
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:184
H264Picture::pps
const PPS * pps
Definition: h264dec.h:151
H264Picture::qscale_table
int8_t * qscale_table
Definition: h264dec.h:113
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:174
H264Picture::ref_index_buf
AVBufferRef * ref_index_buf[2]
Definition: h264dec.h:124
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
mpegutils.h
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:590
H264Picture::invalid_gap
int invalid_gap
Definition: h264dec.h:147
thread.h
ThreadFrame::f
AVFrame * f
Definition: threadframe.h:28
ERPicture
Definition: error_resilience.h:40
H264Picture::frame_num
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:129
H264SliceContext
Definition: h264dec.h:171
H264Picture::mmco_reset
int mmco_reset
MMCO_RESET set this 1.
Definition: h264dec.h:130
fail
#define fail()
Definition: checkasm.h:138
H264Picture::ref_poc
int ref_poc[2][2][32]
POCs of the frames/fields used as reference (FIXME need per slice)
Definition: h264dec.h:135
ERPicture::motion_val
int16_t(*[2] motion_val)[2]
Definition: error_resilience.h:45
ff_thread_replace_frame
int ff_thread_replace_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:890
H264Picture::mb_stride
int mb_stride
Definition: h264dec.h:154
H264Picture::f_grain
AVFrame * f_grain
Definition: h264dec.h:110
refstruct.h
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:589
H264Picture::mbaff
int mbaff
1 -> MBAFF frame 0-> not MBAFF
Definition: h264dec.h:137
emms_c
#define emms_c()
Definition: emms.h:63
ERPicture::field_picture
int field_picture
Definition: error_resilience.h:49
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:67
ff_h264_execute_ref_pic_marking
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:610
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ERPicture::f
AVFrame * f
Definition: error_resilience.h:41
H264Picture::sei_recovery_frame_cnt
int sei_recovery_frame_cnt
Definition: h264dec.h:148
ERPicture::mb_type
uint32_t * mb_type
Definition: error_resilience.h:48
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:871
threadframe.h
H264Picture::motion_val_buf
AVBufferRef * motion_val_buf[2]
Definition: h264dec.h:115
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
hwaccel_internal.h
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1012
H264Picture::mb_height
int mb_height
Definition: h264dec.h:153
ERPicture::tf
const struct ThreadFrame * tf
Definition: error_resilience.h:42
H264Picture::reference
int reference
Definition: h264dec.h:145
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:361
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
H264Picture::tf
ThreadFrame tf
Definition: h264dec.h:108
H264Picture::mb_type
uint32_t * mb_type
Definition: h264dec.h:119
H264Picture::recovered
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:146
AVFrameSideData::data
uint8_t * data
Definition: frame.h:248
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:216
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1543
emms.h
H264Picture::field_picture
int field_picture
whether or not picture was encoded in separate fields
Definition: h264dec.h:138
h264dec.h
ff_h274_apply_film_grain
int ff_h274_apply_film_grain(AVFrame *out_frame, const AVFrame *in_frame, H274FilmGrainDatabase *database, const AVFilmGrainParams *params)
Definition: h274.c:217
H264Picture::needs_fg
int needs_fg
whether picture needs film grain synthesis (see f_grain)
Definition: h264dec.h:149
H264Context
H264Context.
Definition: h264dec.h:331
H264Picture::decode_error_flags
AVBufferRef * decode_error_flags
Definition: h264dec.h:157
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
ff_h264_replace_picture
int ff_h264_replace_picture(H264Picture *dst, const H264Picture *src)
Definition: h264_picture.c:147
h264_copy_picture_params
static void h264_copy_picture_params(H264Picture *dst, const H264Picture *src)
Definition: h264_picture.c:63
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
avcodec.h
ret
ret
Definition: filter_design.txt:187
ff_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:156
AVCodecContext
main external API structure.
Definition: avcodec.h:441
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1551
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:127
error_resilience.h
H264Picture::mb_width
int mb_width
Definition: h264dec.h:153
ff_h264_unref_picture
void ff_h264_unref_picture(H264Picture *pic)
Definition: h264_picture.c:39
H264Picture
Definition: h264dec.h:106
ff_h264_field_end
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:220
H264Picture::mb_type_buf
AVBufferRef * mb_type_buf
Definition: h264dec.h:118
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:246
H264Picture::hwaccel_picture_private
void * hwaccel_picture_private
RefStruct reference for hardware accelerator private data.
Definition: h264dec.h:122
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
H264Picture::qscale_table_buf
AVBufferRef * qscale_table_buf
Definition: h264dec.h:112
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:116
H264Picture::long_ref
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:134
H264Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: h264dec.h:116
ff_h264_set_erpic
void ff_h264_set_erpic(ERPicture *dst, const H264Picture *src)
Definition: h264_picture.c:197
Generated on Thu Apr 18 2024 22:41:50 for FFmpeg by   doxygen 1.8.17