4 * Copyright (C) 2012 - 2013 Guillaume Martres
5 * Copyright (C) 2012 - 2013 Gildas Cocherel
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "libavutil/pixdesc.h"
30 void ff_hevc_unref_frame(HEVCContext
*s
, HEVCFrame
*frame
, int flags
)
32 /* frame->frame can be NULL if context init failed */
33 if (!frame
->frame
|| !frame
->frame
->buf
[0])
36 frame
->flags
&= ~flags
;
38 ff_thread_release_buffer(s
->avctx
, &frame
->tf
);
40 av_buffer_unref(&frame
->tab_mvf_buf
);
41 frame
->tab_mvf
= NULL
;
43 av_buffer_unref(&frame
->rpl_buf
);
44 av_buffer_unref(&frame
->rpl_tab_buf
);
45 frame
->rpl_tab
= NULL
;
46 frame
->refPicList
= NULL
;
48 frame
->collocated_ref
= NULL
;
52 RefPicList
*ff_hevc_get_ref_list(HEVCContext
*s
, HEVCFrame
*ref
, int x0
, int y0
)
54 int x_cb
= x0
>> s
->sps
->log2_ctb_size
;
55 int y_cb
= y0
>> s
->sps
->log2_ctb_size
;
56 int pic_width_cb
= s
->sps
->ctb_width
;
57 int ctb_addr_ts
= s
->pps
->ctb_addr_rs_to_ts
[y_cb
* pic_width_cb
+ x_cb
];
58 return (RefPicList
*)ref
->rpl_tab
[ctb_addr_ts
];
61 void ff_hevc_clear_refs(HEVCContext
*s
)
64 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++)
65 ff_hevc_unref_frame(s
, &s
->DPB
[i
],
66 HEVC_FRAME_FLAG_SHORT_REF
|
67 HEVC_FRAME_FLAG_LONG_REF
);
70 void ff_hevc_flush_dpb(HEVCContext
*s
)
73 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++)
74 ff_hevc_unref_frame(s
, &s
->DPB
[i
], ~0);
77 static HEVCFrame
*alloc_frame(HEVCContext
*s
)
80 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
81 HEVCFrame
*frame
= &s
->DPB
[i
];
82 if (frame
->frame
->buf
[0])
85 ret
= ff_thread_get_buffer(s
->avctx
, &frame
->tf
,
86 AV_GET_BUFFER_FLAG_REF
);
90 frame
->rpl_buf
= av_buffer_allocz(s
->nb_nals
* sizeof(RefPicListTab
));
94 frame
->tab_mvf_buf
= av_buffer_pool_get(s
->tab_mvf_pool
);
95 if (!frame
->tab_mvf_buf
)
97 frame
->tab_mvf
= (MvField
*)frame
->tab_mvf_buf
->data
;
99 frame
->rpl_tab_buf
= av_buffer_pool_get(s
->rpl_tab_pool
);
100 if (!frame
->rpl_tab_buf
)
102 frame
->rpl_tab
= (RefPicListTab
**)frame
->rpl_tab_buf
->data
;
103 frame
->ctb_count
= s
->sps
->ctb_width
* s
->sps
->ctb_height
;
104 for (j
= 0; j
< frame
->ctb_count
; j
++)
105 frame
->rpl_tab
[j
] = (RefPicListTab
*)frame
->rpl_buf
->data
;
107 frame
->frame
->top_field_first
= s
->picture_struct
== AV_PICTURE_STRUCTURE_TOP_FIELD
;
108 frame
->frame
->interlaced_frame
= (s
->picture_struct
== AV_PICTURE_STRUCTURE_TOP_FIELD
) || (s
->picture_struct
== AV_PICTURE_STRUCTURE_BOTTOM_FIELD
);
111 ff_hevc_unref_frame(s
, frame
, ~0);
114 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating frame, DPB full.\n");
118 int ff_hevc_set_new_ref(HEVCContext
*s
, AVFrame
**frame
, int poc
)
123 /* check that this POC doesn't already exist */
124 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
125 HEVCFrame
*frame
= &s
->DPB
[i
];
127 if (frame
->frame
->buf
[0] && frame
->sequence
== s
->seq_decode
&&
129 av_log(s
->avctx
, AV_LOG_ERROR
, "Duplicate POC in a sequence: %d.\n",
131 return AVERROR_INVALIDDATA
;
135 ref
= alloc_frame(s
);
137 return AVERROR(ENOMEM
);
142 if (s
->sh
.pic_output_flag
)
143 ref
->flags
= HEVC_FRAME_FLAG_OUTPUT
| HEVC_FRAME_FLAG_SHORT_REF
;
145 ref
->flags
= HEVC_FRAME_FLAG_SHORT_REF
;
148 ref
->sequence
= s
->seq_decode
;
149 ref
->window
= s
->sps
->output_window
;
154 int ff_hevc_output_frame(HEVCContext
*s
, AVFrame
*out
, int flush
)
158 int min_poc
= INT_MAX
;
161 if (s
->sh
.no_output_of_prior_pics_flag
== 1) {
162 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
163 HEVCFrame
*frame
= &s
->DPB
[i
];
164 if (!(frame
->flags
& HEVC_FRAME_FLAG_BUMPING
) && frame
->poc
!= s
->poc
&&
165 frame
->sequence
== s
->seq_output
) {
166 ff_hevc_unref_frame(s
, frame
, HEVC_FRAME_FLAG_OUTPUT
);
171 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
172 HEVCFrame
*frame
= &s
->DPB
[i
];
173 if ((frame
->flags
& HEVC_FRAME_FLAG_OUTPUT
) &&
174 frame
->sequence
== s
->seq_output
) {
176 if (frame
->poc
< min_poc
) {
177 min_poc
= frame
->poc
;
183 /* wait for more frames before output */
184 if (!flush
&& s
->seq_output
== s
->seq_decode
&& s
->sps
&&
185 nb_output
<= s
->sps
->temporal_layer
[s
->sps
->max_sub_layers
- 1].num_reorder_pics
)
189 HEVCFrame
*frame
= &s
->DPB
[min_idx
];
191 AVFrame
*src
= frame
->frame
;
192 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(src
->format
);
193 int pixel_shift
= !!(desc
->comp
[0].depth_minus1
> 7);
195 ret
= av_frame_ref(out
, src
);
196 if (frame
->flags
& HEVC_FRAME_FLAG_BUMPING
)
197 ff_hevc_unref_frame(s
, frame
, HEVC_FRAME_FLAG_OUTPUT
| HEVC_FRAME_FLAG_BUMPING
);
199 ff_hevc_unref_frame(s
, frame
, HEVC_FRAME_FLAG_OUTPUT
);
203 for (i
= 0; i
< 3; i
++) {
204 int hshift
= (i
> 0) ? desc
->log2_chroma_w
: 0;
205 int vshift
= (i
> 0) ? desc
->log2_chroma_h
: 0;
206 int off
= ((frame
->window
.left_offset
>> hshift
) << pixel_shift
) +
207 (frame
->window
.top_offset
>> vshift
) * dst
->linesize
[i
];
210 av_log(s
->avctx
, AV_LOG_DEBUG
,
211 "Output frame with POC %d.\n", frame
->poc
);
215 if (s
->seq_output
!= s
->seq_decode
)
216 s
->seq_output
= (s
->seq_output
+ 1) & 0xff;
224 void ff_hevc_bump_frame(HEVCContext
*s
)
227 int min_poc
= INT_MAX
;
230 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
231 HEVCFrame
*frame
= &s
->DPB
[i
];
232 if ((frame
->flags
) &&
233 frame
->sequence
== s
->seq_output
&&
234 frame
->poc
!= s
->poc
) {
239 if (s
->sps
&& dpb
>= s
->sps
->temporal_layer
[s
->sps
->max_sub_layers
- 1].max_dec_pic_buffering
) {
240 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
241 HEVCFrame
*frame
= &s
->DPB
[i
];
242 if ((frame
->flags
) &&
243 frame
->sequence
== s
->seq_output
&&
244 frame
->poc
!= s
->poc
) {
245 if (frame
->flags
== HEVC_FRAME_FLAG_OUTPUT
&& frame
->poc
< min_poc
) {
246 min_poc
= frame
->poc
;
251 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
252 HEVCFrame
*frame
= &s
->DPB
[i
];
253 if (frame
->flags
& HEVC_FRAME_FLAG_OUTPUT
&&
254 frame
->sequence
== s
->seq_output
&&
255 frame
->poc
<= min_poc
) {
256 frame
->flags
|= HEVC_FRAME_FLAG_BUMPING
;
264 static int init_slice_rpl(HEVCContext
*s
)
266 HEVCFrame
*frame
= s
->ref
;
267 int ctb_count
= frame
->ctb_count
;
268 int ctb_addr_ts
= s
->pps
->ctb_addr_rs_to_ts
[s
->sh
.slice_segment_addr
];
271 if (s
->slice_idx
>= frame
->rpl_buf
->size
/ sizeof(RefPicListTab
))
272 return AVERROR_INVALIDDATA
;
274 for (i
= ctb_addr_ts
; i
< ctb_count
; i
++)
275 frame
->rpl_tab
[i
] = (RefPicListTab
*)frame
->rpl_buf
->data
+ s
->slice_idx
;
277 frame
->refPicList
= (RefPicList
*)frame
->rpl_tab
[ctb_addr_ts
];
282 int ff_hevc_slice_rpl(HEVCContext
*s
)
284 SliceHeader
*sh
= &s
->sh
;
286 uint8_t nb_list
= sh
->slice_type
== B_SLICE
? 2 : 1;
290 ret
= init_slice_rpl(s
);
294 if (!(s
->rps
[ST_CURR_BEF
].nb_refs
+ s
->rps
[ST_CURR_AFT
].nb_refs
+
295 s
->rps
[LT_CURR
].nb_refs
)) {
296 av_log(s
->avctx
, AV_LOG_ERROR
, "Zero refs in the frame RPS.\n");
297 return AVERROR_INVALIDDATA
;
300 for (list_idx
= 0; list_idx
< nb_list
; list_idx
++) {
301 RefPicList rpl_tmp
= { { 0 } };
302 RefPicList
*rpl
= &s
->ref
->refPicList
[list_idx
];
304 /* The order of the elements is
305 * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and
306 * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */
307 int cand_lists
[3] = { list_idx
? ST_CURR_AFT
: ST_CURR_BEF
,
308 list_idx
? ST_CURR_BEF
: ST_CURR_AFT
,
311 /* concatenate the candidate lists for the current frame */
312 while (rpl_tmp
.nb_refs
< sh
->nb_refs
[list_idx
]) {
313 for (i
= 0; i
< FF_ARRAY_ELEMS(cand_lists
); i
++) {
314 RefPicList
*rps
= &s
->rps
[cand_lists
[i
]];
315 for (j
= 0; j
< rps
->nb_refs
&& rpl_tmp
.nb_refs
< MAX_REFS
; j
++) {
316 rpl_tmp
.list
[rpl_tmp
.nb_refs
] = rps
->list
[j
];
317 rpl_tmp
.ref
[rpl_tmp
.nb_refs
] = rps
->ref
[j
];
318 rpl_tmp
.isLongTerm
[rpl_tmp
.nb_refs
] = i
== 2;
324 /* reorder the references if necessary */
325 if (sh
->rpl_modification_flag
[list_idx
]) {
326 for (i
= 0; i
< sh
->nb_refs
[list_idx
]; i
++) {
327 int idx
= sh
->list_entry_lx
[list_idx
][i
];
329 if (idx
>= rpl_tmp
.nb_refs
) {
330 av_log(s
->avctx
, AV_LOG_ERROR
, "Invalid reference index.\n");
331 return AVERROR_INVALIDDATA
;
334 rpl
->list
[i
] = rpl_tmp
.list
[idx
];
335 rpl
->ref
[i
] = rpl_tmp
.ref
[idx
];
336 rpl
->isLongTerm
[i
] = rpl_tmp
.isLongTerm
[idx
];
340 memcpy(rpl
, &rpl_tmp
, sizeof(*rpl
));
341 rpl
->nb_refs
= FFMIN(rpl
->nb_refs
, sh
->nb_refs
[list_idx
]);
344 if (sh
->collocated_list
== list_idx
&&
345 sh
->collocated_ref_idx
< rpl
->nb_refs
)
346 s
->ref
->collocated_ref
= rpl
->ref
[sh
->collocated_ref_idx
];
352 static HEVCFrame
*find_ref_idx(HEVCContext
*s
, int poc
)
355 int LtMask
= (1 << s
->sps
->log2_max_poc_lsb
) - 1;
357 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
358 HEVCFrame
*ref
= &s
->DPB
[i
];
359 if (ref
->frame
->buf
[0] && (ref
->sequence
== s
->seq_decode
)) {
360 if ((ref
->poc
& LtMask
) == poc
)
365 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
366 HEVCFrame
*ref
= &s
->DPB
[i
];
367 if (ref
->frame
->buf
[0] && ref
->sequence
== s
->seq_decode
) {
368 if (ref
->poc
== poc
|| (ref
->poc
& LtMask
) == poc
)
373 av_log(s
->avctx
, AV_LOG_ERROR
,
374 "Could not find ref with POC %d\n", poc
);
378 static void mark_ref(HEVCFrame
*frame
, int flag
)
380 frame
->flags
&= ~(HEVC_FRAME_FLAG_LONG_REF
| HEVC_FRAME_FLAG_SHORT_REF
);
381 frame
->flags
|= flag
;
384 static HEVCFrame
*generate_missing_ref(HEVCContext
*s
, int poc
)
389 frame
= alloc_frame(s
);
393 if (!s
->sps
->pixel_shift
) {
394 for (i
= 0; frame
->frame
->buf
[i
]; i
++)
395 memset(frame
->frame
->buf
[i
]->data
, 1 << (s
->sps
->bit_depth
- 1),
396 frame
->frame
->buf
[i
]->size
);
398 for (i
= 0; frame
->frame
->data
[i
]; i
++)
399 for (y
= 0; y
< (s
->sps
->height
>> s
->sps
->vshift
[i
]); y
++)
400 for (x
= 0; x
< (s
->sps
->width
>> s
->sps
->hshift
[i
]); x
++) {
401 AV_WN16(frame
->frame
->data
[i
] + y
* frame
->frame
->linesize
[i
] + 2 * x
,
402 1 << (s
->sps
->bit_depth
- 1));
407 frame
->sequence
= s
->seq_decode
;
410 if (s
->threads_type
== FF_THREAD_FRAME
)
411 ff_thread_report_progress(&frame
->tf
, INT_MAX
, 0);
416 /* add a reference with the given poc to the list and mark it as used in DPB */
417 static int add_candidate_ref(HEVCContext
*s
, RefPicList
*list
,
418 int poc
, int ref_flag
)
420 HEVCFrame
*ref
= find_ref_idx(s
, poc
);
423 return AVERROR_INVALIDDATA
;
426 ref
= generate_missing_ref(s
, poc
);
428 return AVERROR(ENOMEM
);
431 list
->list
[list
->nb_refs
] = ref
->poc
;
432 list
->ref
[list
->nb_refs
] = ref
;
435 mark_ref(ref
, ref_flag
);
439 int ff_hevc_frame_rps(HEVCContext
*s
)
441 const ShortTermRPS
*short_rps
= s
->sh
.short_term_rps
;
442 const LongTermRPS
*long_rps
= &s
->sh
.long_term_rps
;
443 RefPicList
*rps
= s
->rps
;
447 rps
[0].nb_refs
= rps
[1].nb_refs
= 0;
451 /* clear the reference flags on all frames except the current one */
452 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++) {
453 HEVCFrame
*frame
= &s
->DPB
[i
];
461 for (i
= 0; i
< NB_RPS_TYPE
; i
++)
464 /* add the short refs */
465 for (i
= 0; i
< short_rps
->num_delta_pocs
; i
++) {
466 int poc
= s
->poc
+ short_rps
->delta_poc
[i
];
469 if (!short_rps
->used
[i
])
471 else if (i
< short_rps
->num_negative_pics
)
476 ret
= add_candidate_ref(s
, &rps
[list
], poc
, HEVC_FRAME_FLAG_SHORT_REF
);
481 /* add the long refs */
482 for (i
= 0; i
< long_rps
->nb_refs
; i
++) {
483 int poc
= long_rps
->poc
[i
];
484 int list
= long_rps
->used
[i
] ? LT_CURR
: LT_FOLL
;
486 ret
= add_candidate_ref(s
, &rps
[list
], poc
, HEVC_FRAME_FLAG_LONG_REF
);
491 /* release any frames that are now unused */
492 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->DPB
); i
++)
493 ff_hevc_unref_frame(s
, &s
->DPB
[i
], 0);
498 int ff_hevc_compute_poc(HEVCContext
*s
, int poc_lsb
)
500 int max_poc_lsb
= 1 << s
->sps
->log2_max_poc_lsb
;
501 int prev_poc_lsb
= s
->pocTid0
% max_poc_lsb
;
502 int prev_poc_msb
= s
->pocTid0
- prev_poc_lsb
;
505 if (poc_lsb
< prev_poc_lsb
&& prev_poc_lsb
- poc_lsb
>= max_poc_lsb
/ 2)
506 poc_msb
= prev_poc_msb
+ max_poc_lsb
;
507 else if (poc_lsb
> prev_poc_lsb
&& poc_lsb
- prev_poc_lsb
> max_poc_lsb
/ 2)
508 poc_msb
= prev_poc_msb
- max_poc_lsb
;
510 poc_msb
= prev_poc_msb
;
512 // For BLA picture types, POCmsb is set to 0.
513 if (s
->nal_unit_type
== NAL_BLA_W_LP
||
514 s
->nal_unit_type
== NAL_BLA_W_RADL
||
515 s
->nal_unit_type
== NAL_BLA_N_LP
)
518 return poc_msb
+ poc_lsb
;
521 int ff_hevc_frame_nb_refs(HEVCContext
*s
)
525 const ShortTermRPS
*rps
= s
->sh
.short_term_rps
;
526 LongTermRPS
*long_rps
= &s
->sh
.long_term_rps
;
529 for (i
= 0; i
< rps
->num_negative_pics
; i
++)
530 ret
+= !!rps
->used
[i
];
531 for (; i
< rps
->num_delta_pocs
; i
++)
532 ret
+= !!rps
->used
[i
];
536 for (i
= 0; i
< long_rps
->nb_refs
; i
++)
537 ret
+= !!long_rps
->used
[i
];