FFmpeg
rl.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  */
18 
19 #include <stdint.h>
20 #include <string.h>
21 
22 #include "libavutil/attributes.h"
23 #include "libavutil/avassert.h"
24 #include "libavutil/mem.h"
25 
26 #include "rl.h"
27 
29 {
30  int i;
31 
32  for (i = 0; i < 2; i++) {
33  av_freep(&rl->max_run[i]);
34  av_freep(&rl->max_level[i]);
35  av_freep(&rl->index_run[i]);
36  }
37 }
38 
40  uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
41 {
42  int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
43  uint8_t index_run[MAX_RUN + 1];
44  int last, run, level, start, end, i;
45 
46  /* If table is static, we can quit if rl->max_level[0] is not NULL */
47  if (static_store && rl->max_level[0])
48  return 0;
49 
50  /* compute max_level[], max_run[] and index_run[] */
51  for (last = 0; last < 2; last++) {
52  if (last == 0) {
53  start = 0;
54  end = rl->last;
55  } else {
56  start = rl->last;
57  end = rl->n;
58  }
59 
60  memset(max_level, 0, MAX_RUN + 1);
61  memset(max_run, 0, MAX_LEVEL + 1);
62  memset(index_run, rl->n, MAX_RUN + 1);
63  for (i = start; i < end; i++) {
64  run = rl->table_run[i];
65  level = rl->table_level[i];
66  if (index_run[run] == rl->n)
67  index_run[run] = i;
68  if (level > max_level[run])
69  max_level[run] = level;
70  if (run > max_run[level])
71  max_run[level] = run;
72  }
73  if (static_store)
74  rl->max_level[last] = static_store[last];
75  else {
76  rl->max_level[last] = av_malloc(MAX_RUN + 1);
77  if (!rl->max_level[last])
78  goto fail;
79  }
80  memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
81  if (static_store)
82  rl->max_run[last] = static_store[last] + MAX_RUN + 1;
83  else {
84  rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
85  if (!rl->max_run[last])
86  goto fail;
87  }
88  memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
89  if (static_store)
90  rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
91  else {
92  rl->index_run[last] = av_malloc(MAX_RUN + 1);
93  if (!rl->index_run[last])
94  goto fail;
95  }
96  memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
97  }
98  return 0;
99 
100 fail:
101  ff_rl_free(rl);
102  return AVERROR(ENOMEM);
103 }
104 
105 av_cold void ff_rl_init_vlc(RLTable *rl, unsigned static_size)
106 {
107  int i, q;
108  VLC_TYPE table[1500][2] = {{0}};
109  VLC vlc = { .table = table, .table_allocated = static_size };
110  av_assert0(static_size <= FF_ARRAY_ELEMS(table));
111  init_vlc(&vlc, 9, rl->n + 1, &rl->table_vlc[0][1], 4, 2, &rl->table_vlc[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC);
112 
113  for (q = 0; q < 32; q++) {
114  int qmul = q * 2;
115  int qadd = (q - 1) | 1;
116 
117  if (q == 0) {
118  qmul = 1;
119  qadd = 0;
120  }
121  for (i = 0; i < vlc.table_size; i++) {
122  int code = vlc.table[i][0];
123  int len = vlc.table[i][1];
124  int level, run;
125 
126  if (len == 0) { // illegal code
127  run = 66;
128  level = MAX_LEVEL;
129  } else if (len < 0) { // more bits needed
130  run = 0;
131  level = code;
132  } else {
133  if (code == rl->n) { // esc
134  run = 66;
135  level = 0;
136  } else {
137  run = rl->table_run[code] + 1;
138  level = rl->table_level[code] * qmul + qadd;
139  if (code >= rl->last) run += 192;
140  }
141  }
142  rl->rl_vlc[q][i].len = len;
143  rl->rl_vlc[q][i].level = level;
144  rl->rl_vlc[q][i].run = run;
145  }
146  }
147 }
int last
number of values for last = 0
Definition: rl.h:41
int table_size
Definition: vlc.h:29
Memory handling functions.
const int8_t * table_level
Definition: rl.h:44
uint8_t run
Definition: svq3.c:206
RLTable.
Definition: rl.h:39
Macro definitions for various function/variable attributes.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int8_t * max_run[2]
encoding & decoding
Definition: rl.h:47
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
#define MAX_LEVEL
Definition: rl.h:36
static const uint16_t table[]
Definition: prosumer.c:206
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
simple assert() macros that are a bit more flexible than ISO C assert().
rl header.
int8_t len
Definition: vlc.h:34
#define fail()
Definition: checkasm.h:120
Definition: vlc.h:26
int n
number of entries of table_vlc minus 1
Definition: rl.h:40
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
const int8_t * table_run
Definition: rl.h:43
void ff_rl_free(RLTable *rl)
Free the contents of a dynamically allocated table.
Definition: rl.c:28
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
#define FF_ARRAY_ELEMS(a)
av_cold int ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:39
uint8_t * index_run[2]
encoding only
Definition: rl.h:45
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
uint8_t level
Definition: svq3.c:207
uint8_t run
Definition: vlc.h:35
#define MAX_RUN
Definition: rl.h:35
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
int len
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int16_t level
Definition: vlc.h:33
av_cold void ff_rl_init_vlc(RLTable *rl, unsigned static_size)
Definition: rl.c:105
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
#define VLC_TYPE
Definition: vlc.h:24
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