Libav
h264_refs.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... reference picture handling
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #include <inttypes.h>
29 
30 #include "internal.h"
31 #include "avcodec.h"
32 #include "h264.h"
33 #include "golomb.h"
34 #include "mpegutils.h"
35 
36 #include <assert.h>
37 
38 #define COPY_PICTURE(dst, src) \
39 do {\
40  *(dst) = *(src);\
41  (dst)->f.extended_data = (dst)->f.data;\
42  (dst)->tf.f = &(dst)->f;\
43 } while (0)
44 
45 
46 static void pic_as_field(H264Picture *pic, const int parity){
47  int i;
48  for (i = 0; i < 4; ++i) {
49  if (parity == PICT_BOTTOM_FIELD)
50  pic->f.data[i] += pic->f.linesize[i];
51  pic->reference = parity;
52  pic->f.linesize[i] *= 2;
53  }
54  pic->poc= pic->field_poc[parity == PICT_BOTTOM_FIELD];
55 }
56 
57 static int split_field_copy(H264Picture *dest, H264Picture *src, int parity, int id_add)
58 {
59  int match = !!(src->reference & parity);
60 
61  if (match) {
62  COPY_PICTURE(dest, src);
63  if (parity != PICT_FRAME) {
64  pic_as_field(dest, parity);
65  dest->pic_id *= 2;
66  dest->pic_id += id_add;
67  }
68  }
69 
70  return match;
71 }
72 
73 static int build_def_list(H264Picture *def, int def_len,
74  H264Picture **in, int len, int is_long, int sel)
75 {
76  int i[2] = { 0 };
77  int index = 0;
78 
79  while ((i[0] < len || i[1] < len) && index < def_len) {
80  while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel)))
81  i[0]++;
82  while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3))))
83  i[1]++;
84  if (i[0] < len && index < def_len) {
85  in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num;
86  split_field_copy(&def[index++], in[i[0]++], sel, 1);
87  }
88  if (i[1] < len && index < def_len) {
89  in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num;
90  split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0);
91  }
92  }
93 
94  return index;
95 }
96 
97 static int add_sorted(H264Picture **sorted, H264Picture **src, int len, int limit, int dir)
98 {
99  int i, best_poc;
100  int out_i = 0;
101 
102  for (;;) {
103  best_poc = dir ? INT_MIN : INT_MAX;
104 
105  for (i = 0; i < len; i++) {
106  const int poc = src[i]->poc;
107  if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) {
108  best_poc = poc;
109  sorted[out_i] = src[i];
110  }
111  }
112  if (best_poc == (dir ? INT_MIN : INT_MAX))
113  break;
114  limit = sorted[out_i++]->poc - dir;
115  }
116  return out_i;
117 }
118 
120 {
121  int i, len;
122 
123  if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
124  H264Picture *sorted[32];
125  int cur_poc, list;
126  int lens[2];
127 
128  if (FIELD_PICTURE(h))
130  else
131  cur_poc = h->cur_pic_ptr->poc;
132 
133  for (list = 0; list < 2; list++) {
134  len = add_sorted(sorted, h->short_ref, h->short_ref_count, cur_poc, 1 ^ list);
135  len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list);
136  assert(len <= 32);
137 
139  sorted, len, 0, h->picture_structure);
140  len += build_def_list(h->default_ref_list[list] + len,
141  FF_ARRAY_ELEMS(h->default_ref_list[0]) - len,
142  h->long_ref, 16, 1, h->picture_structure);
143 
144  if (len < h->ref_count[list])
145  memset(&h->default_ref_list[list][len], 0, sizeof(H264Picture) * (h->ref_count[list] - len));
146  lens[list] = len;
147  }
148 
149  if (lens[0] == lens[1] && lens[1] > 1) {
150  for (i = 0; i < lens[0] &&
151  h->default_ref_list[0][i].f.buf[0]->buffer ==
152  h->default_ref_list[1][i].f.buf[0]->buffer; i++);
153  if (i == lens[0]) {
154  H264Picture tmp;
155  COPY_PICTURE(&tmp, &h->default_ref_list[1][0]);
156  COPY_PICTURE(&h->default_ref_list[1][0], &h->default_ref_list[1][1]);
157  COPY_PICTURE(&h->default_ref_list[1][1], &tmp);
158  }
159  }
160  } else {
163  len += build_def_list(h->default_ref_list[0] + len,
164  FF_ARRAY_ELEMS(h->default_ref_list[0]) - len,
165  h-> long_ref, 16, 1, h->picture_structure);
166 
167  if (len < h->ref_count[0])
168  memset(&h->default_ref_list[0][len], 0, sizeof(H264Picture) * (h->ref_count[0] - len));
169  }
170 #ifdef TRACE
171  for (i = 0; i < h->ref_count[0]; i++) {
172  tprintf(h->avctx, "List0: %s fn:%d 0x%p\n",
173  (h->default_ref_list[0][i].long_ref ? "LT" : "ST"),
174  h->default_ref_list[0][i].pic_id,
175  h->default_ref_list[0][i].f.data[0]);
176  }
177  if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
178  for (i = 0; i < h->ref_count[1]; i++) {
179  tprintf(h->avctx, "List1: %s fn:%d 0x%p\n",
180  (h->default_ref_list[1][i].long_ref ? "LT" : "ST"),
181  h->default_ref_list[1][i].pic_id,
182  h->default_ref_list[1][i].f.data[0]);
183  }
184  }
185 #endif
186  return 0;
187 }
188 
189 static void print_short_term(H264Context *h);
190 static void print_long_term(H264Context *h);
191 
202 static int pic_num_extract(H264Context *h, int pic_num, int *structure)
203 {
204  *structure = h->picture_structure;
205  if (FIELD_PICTURE(h)) {
206  if (!(pic_num & 1))
207  /* opposite field */
208  *structure ^= PICT_FRAME;
209  pic_num >>= 1;
210  }
211 
212  return pic_num;
213 }
214 
216 {
217  int list, index, pic_structure, i;
218 
219  print_short_term(h);
220  print_long_term(h);
221 
222  for (list = 0; list < h->list_count; list++) {
223  for (i = 0; i < h->ref_count[list]; i++)
224  COPY_PICTURE(&h->ref_list[list][i], &h->default_ref_list[list][i]);
225 
226  if (get_bits1(&h->gb)) { // ref_pic_list_modification_flag_l[01]
227  int pred = h->curr_pic_num;
228 
229  for (index = 0; ; index++) {
230  unsigned int modification_of_pic_nums_idc = get_ue_golomb_31(&h->gb);
231  unsigned int pic_id;
232  int i;
233  H264Picture *ref = NULL;
234 
235  if (modification_of_pic_nums_idc == 3)
236  break;
237 
238  if (index >= h->ref_count[list]) {
239  av_log(h->avctx, AV_LOG_ERROR, "reference count overflow\n");
240  return -1;
241  }
242 
243  switch (modification_of_pic_nums_idc) {
244  case 0:
245  case 1: {
246  const unsigned int abs_diff_pic_num = get_ue_golomb(&h->gb) + 1;
247  int frame_num;
248 
249  if (abs_diff_pic_num > h->max_pic_num) {
251  "abs_diff_pic_num overflow\n");
252  return AVERROR_INVALIDDATA;
253  }
254 
255  if (modification_of_pic_nums_idc == 0)
256  pred -= abs_diff_pic_num;
257  else
258  pred += abs_diff_pic_num;
259  pred &= h->max_pic_num - 1;
260 
261  frame_num = pic_num_extract(h, pred, &pic_structure);
262 
263  for (i = h->short_ref_count - 1; i >= 0; i--) {
264  ref = h->short_ref[i];
265  assert(ref->reference);
266  assert(!ref->long_ref);
267  if (ref->frame_num == frame_num &&
268  (ref->reference & pic_structure))
269  break;
270  }
271  if (i >= 0)
272  ref->pic_id = pred;
273  break;
274  }
275  case 2: {
276  int long_idx;
277  pic_id = get_ue_golomb(&h->gb); // long_term_pic_idx
278 
279  long_idx = pic_num_extract(h, pic_id, &pic_structure);
280 
281  if (long_idx > 31) {
283  "long_term_pic_idx overflow\n");
284  return AVERROR_INVALIDDATA;
285  }
286  ref = h->long_ref[long_idx];
287  assert(!(ref && !ref->reference));
288  if (ref && (ref->reference & pic_structure)) {
289  ref->pic_id = pic_id;
290  assert(ref->long_ref);
291  i = 0;
292  } else {
293  i = -1;
294  }
295  break;
296  }
297  default:
299  "illegal modification_of_pic_nums_idc %u\n",
300  modification_of_pic_nums_idc);
301  return AVERROR_INVALIDDATA;
302  }
303 
304  if (i < 0) {
306  "reference picture missing during reorder\n");
307  memset(&h->ref_list[list][index], 0, sizeof(H264Picture)); // FIXME
308  } else {
309  for (i = index; i + 1 < h->ref_count[list]; i++) {
310  if (ref->long_ref == h->ref_list[list][i].long_ref &&
311  ref->pic_id == h->ref_list[list][i].pic_id)
312  break;
313  }
314  for (; i > index; i--) {
315  COPY_PICTURE(&h->ref_list[list][i], &h->ref_list[list][i - 1]);
316  }
317  COPY_PICTURE(&h->ref_list[list][index], ref);
318  if (FIELD_PICTURE(h)) {
319  pic_as_field(&h->ref_list[list][index], pic_structure);
320  }
321  }
322  }
323  }
324  }
325  for (list = 0; list < h->list_count; list++) {
326  for (index = 0; index < h->ref_count[list]; index++) {
327  if (!h->ref_list[list][index].f.buf[0]) {
328  av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture\n");
329  if (h->default_ref_list[list][0].f.buf[0])
330  COPY_PICTURE(&h->ref_list[list][index], &h->default_ref_list[list][0]);
331  else
332  return -1;
333  }
334  }
335  }
336 
337  return 0;
338 }
339 
341 {
342  int list, i, j;
343  for (list = 0; list < 2; list++) { //FIXME try list_count
344  for (i = 0; i < h->ref_count[list]; i++) {
345  H264Picture *frame = &h->ref_list[list][i];
346  H264Picture *field = &h->ref_list[list][16 + 2 * i];
347  COPY_PICTURE(field, frame);
348  for (j = 0; j < 3; j++)
349  field[0].f.linesize[j] <<= 1;
350  field[0].reference = PICT_TOP_FIELD;
351  field[0].poc = field[0].field_poc[0];
352  COPY_PICTURE(field + 1, field);
353  for (j = 0; j < 3; j++)
354  field[1].f.data[j] += frame->f.linesize[j];
355  field[1].reference = PICT_BOTTOM_FIELD;
356  field[1].poc = field[1].field_poc[1];
357 
358  h->luma_weight[16 + 2 * i][list][0] = h->luma_weight[16 + 2 * i + 1][list][0] = h->luma_weight[i][list][0];
359  h->luma_weight[16 + 2 * i][list][1] = h->luma_weight[16 + 2 * i + 1][list][1] = h->luma_weight[i][list][1];
360  for (j = 0; j < 2; j++) {
361  h->chroma_weight[16 + 2 * i][list][j][0] = h->chroma_weight[16 + 2 * i + 1][list][j][0] = h->chroma_weight[i][list][j][0];
362  h->chroma_weight[16 + 2 * i][list][j][1] = h->chroma_weight[16 + 2 * i + 1][list][j][1] = h->chroma_weight[i][list][j][1];
363  }
364  }
365  }
366 }
367 
379 static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
380 {
381  int i;
382  if (pic->reference &= refmask) {
383  return 0;
384  } else {
385  for(i = 0; h->delayed_pic[i]; i++)
386  if(pic == h->delayed_pic[i]){
387  pic->reference = DELAYED_PIC_REF;
388  break;
389  }
390  return 1;
391  }
392 }
393 
402 static H264Picture *find_short(H264Context *h, int frame_num, int *idx)
403 {
404  int i;
405 
406  for (i = 0; i < h->short_ref_count; i++) {
407  H264Picture *pic = h->short_ref[i];
408  if (h->avctx->debug & FF_DEBUG_MMCO)
409  av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
410  if (pic->frame_num == frame_num) {
411  *idx = i;
412  return pic;
413  }
414  }
415  return NULL;
416 }
417 
424 static void remove_short_at_index(H264Context *h, int i)
425 {
426  assert(i >= 0 && i < h->short_ref_count);
427  h->short_ref[i] = NULL;
428  if (--h->short_ref_count)
429  memmove(&h->short_ref[i], &h->short_ref[i + 1],
430  (h->short_ref_count - i) * sizeof(H264Picture*));
431 }
432 
437 static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask)
438 {
439  H264Picture *pic;
440  int i;
441 
442  if (h->avctx->debug & FF_DEBUG_MMCO)
443  av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
444 
445  pic = find_short(h, frame_num, &i);
446  if (pic) {
447  if (unreference_pic(h, pic, ref_mask))
448  remove_short_at_index(h, i);
449  }
450 
451  return pic;
452 }
453 
459 static H264Picture *remove_long(H264Context *h, int i, int ref_mask)
460 {
461  H264Picture *pic;
462 
463  pic = h->long_ref[i];
464  if (pic) {
465  if (unreference_pic(h, pic, ref_mask)) {
466  assert(h->long_ref[i]->long_ref == 1);
467  h->long_ref[i]->long_ref = 0;
468  h->long_ref[i] = NULL;
469  h->long_ref_count--;
470  }
471  }
472 
473  return pic;
474 }
475 
477 {
478  int i;
479 
480  for (i = 0; i < 16; i++) {
481  remove_long(h, i, 0);
482  }
483  assert(h->long_ref_count == 0);
484 
485  for (i = 0; i < h->short_ref_count; i++) {
486  unreference_pic(h, h->short_ref[i], 0);
487  h->short_ref[i] = NULL;
488  }
489  h->short_ref_count = 0;
490 }
491 
496 {
497  uint32_t i;
498  if (h->avctx->debug & FF_DEBUG_MMCO) {
499  av_log(h->avctx, AV_LOG_DEBUG, "short term list:\n");
500  for (i = 0; i < h->short_ref_count; i++) {
501  H264Picture *pic = h->short_ref[i];
502  av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",
503  i, pic->frame_num, pic->poc, pic->f.data[0]);
504  }
505  }
506 }
507 
512 {
513  uint32_t i;
514  if (h->avctx->debug & FF_DEBUG_MMCO) {
515  av_log(h->avctx, AV_LOG_DEBUG, "long term list:\n");
516  for (i = 0; i < 16; i++) {
517  H264Picture *pic = h->long_ref[i];
518  if (pic) {
519  av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",
520  i, pic->frame_num, pic->poc, pic->f.data[0]);
521  }
522  }
523  }
524 }
525 
526 static int check_opcodes(MMCO *mmco1, MMCO *mmco2, int n_mmcos)
527 {
528  int i;
529 
530  for (i = 0; i < n_mmcos; i++) {
531  if (mmco1[i].opcode != mmco2[i].opcode)
532  return -1;
533  }
534 
535  return 0;
536 }
537 
539 {
540  MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = first_slice ? h->mmco : mmco_temp;
541  int mmco_index = 0, i = 0;
542 
543  assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
544 
545  if (h->short_ref_count &&
547  !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
548  mmco[0].opcode = MMCO_SHORT2UNUSED;
549  mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
550  mmco_index = 1;
551  if (FIELD_PICTURE(h)) {
552  mmco[0].short_pic_num *= 2;
553  mmco[1].opcode = MMCO_SHORT2UNUSED;
554  mmco[1].short_pic_num = mmco[0].short_pic_num + 1;
555  mmco_index = 2;
556  }
557  }
558 
559  if (first_slice) {
560  h->mmco_index = mmco_index;
561  } else if (!first_slice && mmco_index >= 0 &&
562  (mmco_index != h->mmco_index ||
563  (i = check_opcodes(h->mmco, mmco_temp, mmco_index)))) {
565  "Inconsistent MMCO state between slices [%d, %d, %d]\n",
566  mmco_index, h->mmco_index, i);
567  return AVERROR_INVALIDDATA;
568  }
569  return 0;
570 }
571 
572 int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count)
573 {
574  int i, av_uninit(j);
575  int current_ref_assigned = 0, err = 0;
576  H264Picture *av_uninit(pic);
577 
578  if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)
579  av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");
580 
581  for (i = 0; i < mmco_count; i++) {
582  int av_uninit(structure), av_uninit(frame_num);
583  if (h->avctx->debug & FF_DEBUG_MMCO)
584  av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,
585  h->mmco[i].short_pic_num, h->mmco[i].long_arg);
586 
587  if (mmco[i].opcode == MMCO_SHORT2UNUSED ||
588  mmco[i].opcode == MMCO_SHORT2LONG) {
589  frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
590  pic = find_short(h, frame_num, &j);
591  if (!pic) {
592  if (mmco[i].opcode != MMCO_SHORT2LONG ||
593  !h->long_ref[mmco[i].long_arg] ||
594  h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
595  av_log(h->avctx, AV_LOG_ERROR, "mmco: unref short failure\n");
596  err = AVERROR_INVALIDDATA;
597  }
598  continue;
599  }
600  }
601 
602  switch (mmco[i].opcode) {
603  case MMCO_SHORT2UNUSED:
604  if (h->avctx->debug & FF_DEBUG_MMCO)
605  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",
607  remove_short(h, frame_num, structure ^ PICT_FRAME);
608  break;
609  case MMCO_SHORT2LONG:
610  if (h->long_ref[mmco[i].long_arg] != pic)
611  remove_long(h, mmco[i].long_arg, 0);
612 
613  remove_short_at_index(h, j);
614  h->long_ref[ mmco[i].long_arg ] = pic;
615  if (h->long_ref[mmco[i].long_arg]) {
616  h->long_ref[mmco[i].long_arg]->long_ref = 1;
617  h->long_ref_count++;
618  }
619  break;
620  case MMCO_LONG2UNUSED:
621  j = pic_num_extract(h, mmco[i].long_arg, &structure);
622  pic = h->long_ref[j];
623  if (pic) {
624  remove_long(h, j, structure ^ PICT_FRAME);
625  } else if (h->avctx->debug & FF_DEBUG_MMCO)
626  av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
627  break;
628  case MMCO_LONG:
629  // Comment below left from previous code as it is an interresting note.
630  /* First field in pair is in short term list or
631  * at a different long term index.
632  * This is not allowed; see 7.4.3.3, notes 2 and 3.
633  * Report the problem and keep the pair where it is,
634  * and mark this field valid.
635  */
636  if (h->short_ref[0] == h->cur_pic_ptr)
637  remove_short_at_index(h, 0);
638 
639  if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
640  remove_long(h, mmco[i].long_arg, 0);
641 
642  h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr;
643  h->long_ref[mmco[i].long_arg]->long_ref = 1;
644  h->long_ref_count++;
645  }
646 
648  current_ref_assigned = 1;
649  break;
650  case MMCO_SET_MAX_LONG:
651  assert(mmco[i].long_arg <= 16);
652  // just remove the long term which index is greater than new max
653  for (j = mmco[i].long_arg; j < 16; j++) {
654  remove_long(h, j, 0);
655  }
656  break;
657  case MMCO_RESET:
658  while (h->short_ref_count) {
659  remove_short(h, h->short_ref[0]->frame_num, 0);
660  }
661  for (j = 0; j < 16; j++) {
662  remove_long(h, j, 0);
663  }
664  h->frame_num = h->cur_pic_ptr->frame_num = 0;
665  h->mmco_reset = 1;
666  h->cur_pic_ptr->mmco_reset = 1;
667  break;
668  default: assert(0);
669  }
670  }
671 
672  if (!current_ref_assigned) {
673  /* Second field of complementary field pair; the first field of
674  * which is already referenced. If short referenced, it
675  * should be first entry in short_ref. If not, it must exist
676  * in long_ref; trying to put it on the short list here is an
677  * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
678  */
679  if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
680  /* Just mark the second field valid */
682  } else if (h->cur_pic_ptr->long_ref) {
683  av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
684  "assignment for second field "
685  "in complementary field pair "
686  "(first field is long term)\n");
687  err = AVERROR_INVALIDDATA;
688  } else {
689  pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);
690  if (pic) {
691  av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
692  err = AVERROR_INVALIDDATA;
693  }
694 
695  if (h->short_ref_count)
696  memmove(&h->short_ref[1], &h->short_ref[0],
697  h->short_ref_count * sizeof(H264Picture*));
698 
699  h->short_ref[0] = h->cur_pic_ptr;
700  h->short_ref_count++;
702  }
703  }
704 
705  if (h->long_ref_count + h->short_ref_count -
706  (h->short_ref[0] == h->cur_pic_ptr) > h->sps.ref_frame_count) {
707 
708  /* We have too many reference frames, probably due to corrupted
709  * stream. Need to discard one frame. Prevents overrun of the
710  * short_ref and long_ref buffers.
711  */
713  "number of reference frames (%d+%d) exceeds max (%d; probably "
714  "corrupt input), discarding one\n",
716  err = AVERROR_INVALIDDATA;
717 
718  if (h->long_ref_count && !h->short_ref_count) {
719  for (i = 0; i < 16; ++i)
720  if (h->long_ref[i])
721  break;
722 
723  assert(i < 16);
724  remove_long(h, i, 0);
725  } else {
726  pic = h->short_ref[h->short_ref_count - 1];
727  remove_short(h, pic->frame_num, 0);
728  }
729  }
730 
731  print_short_term(h);
732  print_long_term(h);
733  return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
734 }
735 
737  int first_slice)
738 {
739  int i, ret;
740  MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = first_slice ? h->mmco : mmco_temp;
741  int mmco_index = 0;
742 
743  if (h->nal_unit_type == NAL_IDR_SLICE) { // FIXME fields
744  skip_bits1(gb); // broken_link
745  if (get_bits1(gb)) {
746  mmco[0].opcode = MMCO_LONG;
747  mmco[0].long_arg = 0;
748  mmco_index = 1;
749  }
750  } else {
751  if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
752  for (i = 0; i < MAX_MMCO_COUNT; i++) {
753  MMCOOpcode opcode = get_ue_golomb_31(gb);
754 
755  mmco[i].opcode = opcode;
756  if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
757  mmco[i].short_pic_num =
758  (h->curr_pic_num - get_ue_golomb(gb) - 1) &
759  (h->max_pic_num - 1);
760 #if 0
761  if (mmco[i].short_pic_num >= h->short_ref_count ||
762  !h->short_ref[mmco[i].short_pic_num]) {
763  av_log(s->avctx, AV_LOG_ERROR,
764  "illegal short ref in memory management control "
765  "operation %d\n", mmco);
766  return -1;
767  }
768 #endif
769  }
770  if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
771  opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
772  unsigned int long_arg = get_ue_golomb_31(gb);
773  if (long_arg >= 32 ||
774  (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
775  long_arg == 16) &&
776  !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(h)))) {
778  "illegal long ref in memory management control "
779  "operation %d\n", opcode);
780  return -1;
781  }
782  mmco[i].long_arg = long_arg;
783  }
784 
785  if (opcode > (unsigned) MMCO_LONG) {
787  "illegal memory management control operation %d\n",
788  opcode);
789  return -1;
790  }
791  if (opcode == MMCO_END)
792  break;
793  }
794  mmco_index = i;
795  } else {
796  if (first_slice) {
797  ret = ff_generate_sliding_window_mmcos(h, first_slice);
798  if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
799  return ret;
800  }
801  mmco_index = -1;
802  }
803  }
804 
805  if (first_slice && mmco_index != -1) {
806  h->mmco_index = mmco_index;
807  } else if (!first_slice && mmco_index >= 0 &&
808  (mmco_index != h->mmco_index ||
809  check_opcodes(h->mmco, mmco_temp, mmco_index))) {
811  "Inconsistent MMCO state between slices [%d, %d]\n",
812  mmco_index, h->mmco_index);
813  return AVERROR_INVALIDDATA;
814  }
815 
816  return 0;
817 }
Memory management control operation.
Definition: h264.h:257
static int pic_num_extract(H264Context *h, int pic_num, int *structure)
Extract structure information about the picture described by pic_num in the current decoding context ...
Definition: h264_refs.c:202
static int add_sorted(H264Picture **sorted, H264Picture **src, int len, int limit, int dir)
Definition: h264_refs.c:97
int long_ref
1->long term reference 0->short term reference
Definition: h264.h:289
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
GetBitContext gb
Definition: h264.h:311
static H264Picture * remove_short(H264Context *h, int frame_num, int ref_mask)
Definition: h264_refs.c:437
int first_field
Definition: h264.h:420
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:393
static int check_opcodes(MMCO *mmco1, MMCO *mmco2, int n_mmcos)
Definition: h264_refs.c:526
MMCO mmco[MAX_MMCO_COUNT]
memory management control operations buffer.
Definition: h264.h:575
int ff_h264_fill_default_ref_list(H264Context *h)
Fill the default_ref_list.
Definition: h264_refs.c:119
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
H264Picture * delayed_pic[MAX_DELAYED_PIC_COUNT+2]
Definition: h264.h:566
void ff_h264_fill_mbaff_ref_list(H264Context *h)
Definition: h264_refs.c:340
int mmco_index
Definition: h264.h:576
int ff_h264_decode_ref_pic_list_reordering(H264Context *h)
Definition: h264_refs.c:215
MMCOOpcode
Memory management control operation opcode.
Definition: h264.h:244
static int build_def_list(H264Picture *def, int def_len, H264Picture **in, int len, int is_long, int sel)
Definition: h264_refs.c:73
#define FF_ARRAY_ELEMS(a)
H264Context.
Definition: h264.h:303
struct AVFrame f
Definition: h264.h:264
H264Picture * long_ref[32]
Definition: h264.h:565
int picture_structure
Definition: h264.h:419
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264.h:412
MMCOOpcode opcode
Definition: h264.h:258
static void pic_as_field(H264Picture *pic, const int parity)
Definition: h264_refs.c:46
void ff_h264_remove_all_refs(H264Context *h)
Definition: h264_refs.c:476
int short_pic_num
pic_num without wrapping (pic_num & max_pic_num)
Definition: h264.h:259
int luma_weight[48][2][2]
Definition: h264.h:430
int poc
frame POC
Definition: h264.h:283
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:445
int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb, int first_slice)
Definition: h264_refs.c:736
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:34
H264Picture default_ref_list[2][32]
base reference list for all slices of a coded picture
Definition: h264.h:563
int ff_generate_sliding_window_mmcos(H264Context *h, int first_slice)
Definition: h264_refs.c:538
int chroma_weight[48][2][2][2]
Definition: h264.h:431
H.264 / AVC / MPEG4 part10 codec.
int frame_num
Definition: h264.h:544
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
static int get_ue_golomb(GetBitContext *gb)
read unsigned exp golomb code.
Definition: golomb.h:53
int nal_unit_type
Definition: h264.h:518
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
#define PICT_TOP_FIELD
Definition: mpegutils.h:33
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
#define COPY_PICTURE(dst, src)
Definition: h264_refs.c:38
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264.h:284
static int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
Mark a picture as no longer needed for reference.
Definition: h264_refs.c:379
int ref_frame_count
num_ref_frames
Definition: h264.h:169
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2406
static int split_field_copy(H264Picture *dest, H264Picture *src, int parity, int id_add)
Definition: h264_refs.c:57
int reference
Definition: h264.h:296
#define FIELD_PICTURE(h)
Definition: h264.h:72
int long_ref_count
number of actual long term references
Definition: h264.h:579
SPS sps
current sps
Definition: h264.h:401
H264Picture ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264.h:448
int mmco_reset
Definition: h264.h:577
#define FF_DEBUG_MMCO
Definition: avcodec.h:2381
#define AV_EF_EXPLODE
Definition: avcodec.h:2417
int max_pic_num
max_frame_num or 2 * max_frame_num for field pics.
Definition: h264.h:559
int curr_pic_num
frame_num for frames or 2 * frame_num + 1 for field pics.
Definition: h264.h:554
static void remove_short_at_index(H264Context *h, int i)
Remove a picture from the short term reference list by its index in that list.
Definition: h264_refs.c:424
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output...
Definition: mpegutils.h:41
unsigned int list_count
Definition: h264.h:446
static H264Picture * find_short(H264Context *h, int frame_num, int *idx)
Find a H264Picture in the short term reference list by frame number.
Definition: h264_refs.c:402
static const float pred[4]
Definition: siprdata.h:259
NULL
Definition: eval.c:55
AVCodecContext * avctx
Definition: h264.h:304
int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:572
Libavcodec external API header.
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:96
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:153
H264Picture * short_ref[32]
Definition: h264.h:564
int field_poc[2]
top/bottom POC
Definition: h264.h:282
int debug
debug
Definition: avcodec.h:2362
Definition: h264.h:245
AVBuffer * buffer
Definition: buffer.h:82
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:296
int index
Definition: gxfenc.c:72
#define MAX_MMCO_COUNT
Definition: h264.h:52
int mmco_reset
MMCO_RESET set this 1.
Definition: h264.h:285
static H264Picture * remove_long(H264Context *h, int i, int ref_mask)
Remove a picture from the long term reference list by its index in that list.
Definition: h264_refs.c:459
H264Picture * cur_pic_ptr
Definition: h264.h:315
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
int pic_id
pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num) ...
Definition: h264.h:287
#define tprintf(p,...)
Definition: get_bits.h:626
common internal api header.
Bi-dir predicted.
Definition: avutil.h:255
int long_arg
index, pic_num, or num long refs depending on opcode
Definition: h264.h:260
#define PICT_FRAME
Definition: mpegutils.h:35
int len
static void print_long_term(H264Context *h)
print long term list
Definition: h264_refs.c:511
#define av_uninit(x)
Definition: attributes.h:109
exp golomb vlc stuff
static void print_short_term(H264Context *h)
print short term list
Definition: h264_refs.c:495
for(j=16;j >0;--j)
int short_ref_count
number of actual short term references
Definition: h264.h:580