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 "error_resilience.h"
30 #include "avcodec.h"
31 #include "h264dec.h"
32 #include "mpegutils.h"
33 #include "thread.h"
34 
36 {
37  int off = offsetof(H264Picture, tf_grain) + sizeof(pic->tf_grain);
38  int i;
39 
40  if (!pic->f || !pic->f->buf[0])
41  return;
42 
43  ff_thread_release_buffer(h->avctx, &pic->tf);
44  ff_thread_release_buffer(h->avctx, &pic->tf_grain);
46 
49  av_buffer_unref(&pic->pps_buf);
50  for (i = 0; i < 2; i++) {
53  }
54 
55  memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
56 }
57 
59 {
60  dst->qscale_table = src->qscale_table;
61  dst->mb_type = src->mb_type;
62  dst->pps = src->pps;
63 
64  for (int i = 0; i < 2; i++) {
65  dst->motion_val[i] = src->motion_val[i];
66  dst->ref_index[i] = src->ref_index[i];
67  }
68 
69  for (int i = 0; i < 2; i++)
70  dst->field_poc[i] = src->field_poc[i];
71 
72  memcpy(dst->ref_poc, src->ref_poc, sizeof(src->ref_poc));
73  memcpy(dst->ref_count, src->ref_count, sizeof(src->ref_count));
74 
75  dst->poc = src->poc;
76  dst->frame_num = src->frame_num;
77  dst->mmco_reset = src->mmco_reset;
78  dst->long_ref = src->long_ref;
79  dst->mbaff = src->mbaff;
80  dst->field_picture = src->field_picture;
81  dst->reference = src->reference;
82  dst->recovered = src->recovered;
83  dst->invalid_gap = src->invalid_gap;
84  dst->sei_recovery_frame_cnt = src->sei_recovery_frame_cnt;
85  dst->mb_width = src->mb_width;
86  dst->mb_height = src->mb_height;
87  dst->mb_stride = src->mb_stride;
88  dst->needs_fg = src->needs_fg;
89 }
90 
92 {
93  int ret, i;
94 
95  av_assert0(!dst->f->buf[0]);
96  av_assert0(src->f->buf[0]);
97  av_assert0(src->tf.f == src->f);
98 
99  dst->tf.f = dst->f;
100  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
101  if (ret < 0)
102  goto fail;
103 
104  if (src->needs_fg) {
105  av_assert0(src->tf_grain.f == src->f_grain);
106  dst->tf_grain.f = dst->f_grain;
107  ret = ff_thread_ref_frame(&dst->tf_grain, &src->tf_grain);
108  if (ret < 0)
109  goto fail;
110  }
111 
112  dst->qscale_table_buf = av_buffer_ref(src->qscale_table_buf);
113  dst->mb_type_buf = av_buffer_ref(src->mb_type_buf);
114  dst->pps_buf = av_buffer_ref(src->pps_buf);
115  if (!dst->qscale_table_buf || !dst->mb_type_buf || !dst->pps_buf) {
116  ret = AVERROR(ENOMEM);
117  goto fail;
118  }
119 
120  for (i = 0; i < 2; i++) {
121  dst->motion_val_buf[i] = av_buffer_ref(src->motion_val_buf[i]);
122  dst->ref_index_buf[i] = av_buffer_ref(src->ref_index_buf[i]);
123  if (!dst->motion_val_buf[i] || !dst->ref_index_buf[i]) {
124  ret = AVERROR(ENOMEM);
125  goto fail;
126  }
127  }
128 
129  if (src->hwaccel_picture_private) {
130  dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
131  if (!dst->hwaccel_priv_buf) {
132  ret = AVERROR(ENOMEM);
133  goto fail;
134  }
136  }
137 
139 
140  return 0;
141 fail:
142  ff_h264_unref_picture(h, dst);
143  return ret;
144 }
145 
147 {
148  int ret, i;
149 
150  if (!src->f || !src->f->buf[0]) {
151  ff_h264_unref_picture(h, dst);
152  return 0;
153  }
154 
155  av_assert0(src->tf.f == src->f);
156 
157  dst->tf.f = dst->f;
158  ff_thread_release_buffer(h->avctx, &dst->tf);
159  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
160  if (ret < 0)
161  goto fail;
162 
163  if (src->needs_fg) {
164  av_assert0(src->tf_grain.f == src->f_grain);
165  dst->tf_grain.f = dst->f_grain;
166  ff_thread_release_buffer(h->avctx, &dst->tf_grain);
167  ret = ff_thread_ref_frame(&dst->tf_grain, &src->tf_grain);
168  if (ret < 0)
169  goto fail;
170  }
171 
172  ret = av_buffer_replace(&dst->qscale_table_buf, src->qscale_table_buf);
173  ret |= av_buffer_replace(&dst->mb_type_buf, src->mb_type_buf);
174  ret |= av_buffer_replace(&dst->pps_buf, src->pps_buf);
175  if (ret < 0)
176  goto fail;
177 
178  for (i = 0; i < 2; i++) {
179  ret = av_buffer_replace(&dst->motion_val_buf[i], src->motion_val_buf[i]);
180  ret |= av_buffer_replace(&dst->ref_index_buf[i], src->ref_index_buf[i]);
181  if (ret < 0)
182  goto fail;
183  }
184 
185  ret = av_buffer_replace(&dst->hwaccel_priv_buf, src->hwaccel_priv_buf);
186  if (ret < 0)
187  goto fail;
188 
189  dst->hwaccel_picture_private = src->hwaccel_picture_private;
190 
192 
193  return 0;
194 fail:
195  ff_h264_unref_picture(h, dst);
196  return ret;
197 }
198 
200 {
201 #if CONFIG_ERROR_RESILIENCE
202  int i;
203 
204  memset(dst, 0, sizeof(*dst));
205 
206  if (!src)
207  return;
208 
209  dst->f = src->f;
210  dst->tf = &src->tf;
211 
212  for (i = 0; i < 2; i++) {
213  dst->motion_val[i] = src->motion_val[i];
214  dst->ref_index[i] = src->ref_index[i];
215  }
216 
217  dst->mb_type = src->mb_type;
218  dst->field_picture = src->field_picture;
219 #endif /* CONFIG_ERROR_RESILIENCE */
220 }
221 
223 {
224  AVCodecContext *const avctx = h->avctx;
225  H264Picture *cur = h->cur_pic_ptr;
226  int err = 0;
227  h->mb_y = 0;
228 
229  if (in_setup || !(avctx->active_thread_type & FF_THREAD_FRAME)) {
230  if (!h->droppable) {
232  h->poc.prev_poc_msb = h->poc.poc_msb;
233  h->poc.prev_poc_lsb = h->poc.poc_lsb;
234  }
235  h->poc.prev_frame_num_offset = h->poc.frame_num_offset;
236  h->poc.prev_frame_num = h->poc.frame_num;
237  }
238 
239  if (avctx->hwaccel) {
240  err = avctx->hwaccel->end_frame(avctx);
241  if (err < 0)
242  av_log(avctx, AV_LOG_ERROR,
243  "hardware accelerator failed to decode picture\n");
244  } else if (!in_setup && cur->needs_fg && (!FIELD_PICTURE(h) || !h->first_field)) {
246 
247  err = AVERROR_INVALIDDATA;
248  if (sd) // a decoding error may have happened before the side data could be allocated
249  err = ff_h274_apply_film_grain(cur->f_grain, cur->f, &h->h274db,
250  (AVFilmGrainParams *) sd->data);
251  if (err < 0) {
252  av_log(h->avctx, AV_LOG_WARNING, "Failed synthesizing film "
253  "grain, ignoring: %s\n", av_err2str(err));
254  cur->needs_fg = 0;
255  err = 0;
256  }
257  }
258 
259  if (!in_setup && !h->droppable)
260  ff_thread_report_progress(&cur->tf, INT_MAX,
261  h->picture_structure == PICT_BOTTOM_FIELD);
262  emms_c();
263 
264  h->current_slice = 0;
265 
266  return err;
267 }
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1359
ff_h264_unref_picture
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
Definition: h264_picture.c:35
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
ERPicture::tf
ThreadFrame * tf
Definition: error_resilience.h:43
H264Picture::poc
int poc
frame POC
Definition: h264dec.h:130
H264Picture::f
AVFrame * f
Definition: h264dec.h:108
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:866
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:617
ff_h264_replace_picture
int ff_h264_replace_picture(H264Context *h, H264Picture *dst, const H264Picture *src)
Definition: h264_picture.c:146
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
H264Picture::ref_count
int ref_count[2][2]
number of entries in ref_poc (FIXME need per slice)
Definition: h264dec.h:138
H264Picture::ref_index
int8_t * ref_index[2]
Definition: h264dec.h:127
ff_h264_set_erpic
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)
Definition: h264_picture.c:199
ERPicture::ref_index
int8_t * ref_index[2]
Definition: error_resilience.h:47
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:183
H264Picture::pps
const PPS * pps
Definition: h264dec.h:149
H264Picture::qscale_table
int8_t * qscale_table
Definition: h264dec.h:115
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
H264Picture::ref_index_buf
AVBufferRef * ref_index_buf[2]
Definition: h264dec.h:126
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:513
H264Picture::invalid_gap
int invalid_gap
Definition: h264dec.h:144
H264Picture::pps_buf
AVBufferRef * pps_buf
Definition: h264dec.h:148
thread.h
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
ERPicture
Definition: error_resilience.h:41
H264Picture::frame_num
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:131
H264SliceContext
Definition: h264dec.h:166
H264Picture::mmco_reset
int mmco_reset
MMCO_RESET set this 1.
Definition: h264dec.h:132
fail
#define fail()
Definition: checkasm.h:128
H264Picture::ref_poc
int ref_poc[2][2][32]
POCs of the frames/fields used as reference (FIXME need per slice)
Definition: h264dec.h:137
ERPicture::motion_val
int16_t(*[2] motion_val)[2]
Definition: error_resilience.h:46
H264Picture::mb_stride
int mb_stride
Definition: h264dec.h:152
H264Picture::f_grain
AVFrame * f_grain
Definition: h264dec.h:111
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:588
H264Picture::mbaff
int mbaff
1 -> MBAFF frame 0-> not MBAFF
Definition: h264dec.h:139
ERPicture::field_picture
int field_picture
Definition: error_resilience.h:50
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:68
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:37
ERPicture::f
AVFrame * f
Definition: error_resilience.h:42
H264Picture::sei_recovery_frame_cnt
int sei_recovery_frame_cnt
Definition: h264dec.h:145
ERPicture::mb_type
uint32_t * mb_type
Definition: error_resilience.h:49
H264Picture::motion_val_buf
AVBufferRef * motion_val_buf[2]
Definition: h264dec.h:117
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
AVHWAccel::end_frame
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:2140
H264Picture::mb_height
int mb_height
Definition: h264dec.h:151
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1056
H264Picture::reference
int reference
Definition: h264dec.h:142
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:109
H264Picture::mb_type
uint32_t * mb_type
Definition: h264dec.h:121
H264Picture::recovered
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:143
AVFrameSideData::data
uint8_t * data
Definition: frame.h:225
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:1451
H264Picture::field_picture
int field_picture
whether or not picture was encoded in separate fields
Definition: h264dec.h:140
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:146
H264Context
H264Context.
Definition: h264dec.h:327
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
H264Picture::hwaccel_priv_buf
AVBufferRef * hwaccel_priv_buf
Definition: h264dec.h:123
h264_copy_picture_params
static void h264_copy_picture_params(H264Picture *dst, const H264Picture *src)
Definition: h264_picture.c:58
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
ff_h264_ref_picture
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
Definition: h264_picture.c:91
ret
ret
Definition: filter_design.txt:187
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1459
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:129
error_resilience.h
H264Picture::mb_width
int mb_width
Definition: h264dec.h:151
H264Picture
Definition: h264dec.h:107
H264Picture::tf_grain
ThreadFrame tf_grain
Definition: h264dec.h:112
ff_h264_field_end
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:222
H264Picture::mb_type_buf
AVBufferRef * mb_type_buf
Definition: h264dec.h:120
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:223
H264Picture::hwaccel_picture_private
void * hwaccel_picture_private
hardware accelerator private data
Definition: h264dec.h:124
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:114
H264Picture::long_ref
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:136
H264Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: h264dec.h:118