avcodec/dvbsubdec: Compute scoretab without iterating over pixels multiple times...
[ffmpeg.git] / libavcodec / cbs_vp9_syntax_template.c
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 static int FUNC(frame_sync_code)(CodedBitstreamContext *ctx, RWContext *rw,
20                                  VP9RawFrameHeader *current)
21 {
22     uint8_t frame_sync_byte_0 = VP9_FRAME_SYNC_0;
23     uint8_t frame_sync_byte_1 = VP9_FRAME_SYNC_1;
24     uint8_t frame_sync_byte_2 = VP9_FRAME_SYNC_2;
25     int err;
26
27     xf(8, frame_sync_byte_0, frame_sync_byte_0, 0);
28     xf(8, frame_sync_byte_1, frame_sync_byte_1, 0);
29     xf(8, frame_sync_byte_2, frame_sync_byte_2, 0);
30
31     if (frame_sync_byte_0 != VP9_FRAME_SYNC_0 ||
32         frame_sync_byte_1 != VP9_FRAME_SYNC_1 ||
33         frame_sync_byte_2 != VP9_FRAME_SYNC_2) {
34         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid frame sync code: "
35                "%02x %02x %02x.\n", frame_sync_byte_0,
36                frame_sync_byte_1, frame_sync_byte_2);
37         return AVERROR_INVALIDDATA;
38     }
39
40     return 0;
41 }
42
43 static int FUNC(color_config)(CodedBitstreamContext *ctx, RWContext *rw,
44                               VP9RawFrameHeader *current, int profile)
45 {
46     int err;
47
48     if (profile >= 2)
49         f(1, ten_or_twelve_bit);
50
51     f(3, color_space);
52
53     if (current->color_space != VP9_CS_RGB) {
54         f(1, color_range);
55         if (profile == 1 || profile == 3) {
56             f(1, subsampling_x);
57             f(1, subsampling_y);
58             f(1, color_config_reserved_zero);
59         } else {
60             infer(subsampling_x, 1);
61             infer(subsampling_y, 1);
62         }
63     } else {
64         infer(color_range, 1);
65         if (profile == 1 || profile == 3) {
66             infer(subsampling_x, 0);
67             infer(subsampling_y, 0);
68         }
69     }
70
71     return 0;
72 }
73
74 static int FUNC(frame_size)(CodedBitstreamContext *ctx, RWContext *rw,
75                             VP9RawFrameHeader *current)
76 {
77     CodedBitstreamVP9Context *vp9 = ctx->priv_data;
78     int err;
79
80     f(16, frame_width_minus_1);
81     f(16, frame_height_minus_1);
82
83     vp9->mi_cols = (current->frame_width_minus_1  + 8) >> 3;
84     vp9->mi_rows = (current->frame_height_minus_1 + 8) >> 3;
85     vp9->sb64_cols = (vp9->mi_cols + 7) >> 3;
86     vp9->sb64_rows = (vp9->mi_rows + 7) >> 3;
87
88     return 0;
89 }
90
91 static int FUNC(render_size)(CodedBitstreamContext *ctx, RWContext *rw,
92                              VP9RawFrameHeader *current)
93 {
94     int err;
95
96     f(1, render_and_frame_size_different);
97
98     if (current->render_and_frame_size_different) {
99         f(16, render_width_minus_1);
100         f(16, render_height_minus_1);
101     }
102
103     return 0;
104 }
105
106 static int FUNC(frame_size_with_refs)(CodedBitstreamContext *ctx, RWContext *rw,
107                                       VP9RawFrameHeader *current)
108 {
109     int err, i;
110
111     for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
112         fs(1, found_ref[i], 1, i);
113         if (current->found_ref[i])
114             break;
115     }
116     if (i >= VP9_REFS_PER_FRAME)
117         CHECK(FUNC(frame_size)(ctx, rw, current));
118     CHECK(FUNC(render_size)(ctx, rw, current));
119
120     return 0;
121 }
122
123 static int FUNC(interpolation_filter)(CodedBitstreamContext *ctx, RWContext *rw,
124                                       VP9RawFrameHeader *current)
125 {
126     int err;
127
128     f(1, is_filter_switchable);
129     if (!current->is_filter_switchable)
130         f(2, raw_interpolation_filter_type);
131
132     return 0;
133 }
134
135 static int FUNC(loop_filter_params)(CodedBitstreamContext *ctx, RWContext *rw,
136                                     VP9RawFrameHeader *current)
137 {
138     int err, i;
139
140     f(6, loop_filter_level);
141     f(3, loop_filter_sharpness);
142
143     f(1, loop_filter_delta_enabled);
144     if (current->loop_filter_delta_enabled) {
145         f(1, loop_filter_delta_update);
146         if (current->loop_filter_delta_update) {
147             for (i = 0; i < VP9_MAX_REF_FRAMES; i++) {
148                 fs(1, update_ref_delta[i], 1, i);
149                 if (current->update_ref_delta[i])
150                     ss(6, loop_filter_ref_deltas[i], 1, i);
151             }
152             for (i = 0; i < 2; i++) {
153                 fs(1, update_mode_delta[i], 1, i);
154                 if (current->update_mode_delta[i])
155                     ss(6, loop_filter_mode_deltas[i], 1, i);
156             }
157         }
158     }
159
160     return 0;
161 }
162
163 static int FUNC(quantization_params)(CodedBitstreamContext *ctx, RWContext *rw,
164                                      VP9RawFrameHeader *current)
165 {
166     int err;
167
168     f(8, base_q_idx);
169
170     delta_q(delta_q_y_dc);
171     delta_q(delta_q_uv_dc);
172     delta_q(delta_q_uv_ac);
173
174     return 0;
175 }
176
177 static int FUNC(segmentation_params)(CodedBitstreamContext *ctx, RWContext *rw,
178                                      VP9RawFrameHeader *current)
179 {
180     static const int segmentation_feature_bits[VP9_SEG_LVL_MAX]   = { 8, 6, 2, 0 };
181     static const int segmentation_feature_signed[VP9_SEG_LVL_MAX] = { 1, 1, 0, 0 };
182
183     int err, i, j;
184
185     f(1, segmentation_enabled);
186
187     if (current->segmentation_enabled) {
188         f(1, segmentation_update_map);
189         if (current->segmentation_update_map) {
190             for (i = 0; i < 7; i++)
191                 prob(segmentation_tree_probs[i], 1, i);
192             f(1, segmentation_temporal_update);
193             for (i = 0; i < 3; i++) {
194                 if (current->segmentation_temporal_update)
195                     prob(segmentation_pred_prob[i], 1, i);
196                 else
197                     infer(segmentation_pred_prob[i], 255);
198             }
199         }
200
201         f(1, segmentation_update_data);
202         if (current->segmentation_update_data) {
203             f(1, segmentation_abs_or_delta_update);
204             for (i = 0; i < VP9_MAX_SEGMENTS; i++) {
205                 for (j = 0; j < VP9_SEG_LVL_MAX; j++) {
206                     fs(1, feature_enabled[i][j], 2, i, j);
207                     if (current->feature_enabled[i][j] &&
208                         segmentation_feature_bits[j]) {
209                         fs(segmentation_feature_bits[j],
210                            feature_value[i][j], 2, i, j);
211                         if (segmentation_feature_signed[j])
212                             fs(1, feature_sign[i][j], 2, i, j);
213                         else
214                             infer(feature_sign[i][j], 0);
215                     } else {
216                         infer(feature_value[i][j], 0);
217                         infer(feature_sign[i][j],  0);
218                     }
219                 }
220             }
221         }
222     }
223
224     return 0;
225 }
226
227 static int FUNC(tile_info)(CodedBitstreamContext *ctx, RWContext *rw,
228                            VP9RawFrameHeader *current)
229 {
230     CodedBitstreamVP9Context *vp9 = ctx->priv_data;
231     int min_log2_tile_cols, max_log2_tile_cols;
232     int err;
233
234     min_log2_tile_cols = 0;
235     while ((VP9_MAX_TILE_WIDTH_B64 << min_log2_tile_cols) < vp9->sb64_cols)
236         ++min_log2_tile_cols;
237     max_log2_tile_cols = 0;
238     while ((vp9->sb64_cols >> (max_log2_tile_cols + 1)) >= VP9_MIN_TILE_WIDTH_B64)
239         ++max_log2_tile_cols;
240
241     increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);
242
243     increment(tile_rows_log2, 0, 2);
244
245     return 0;
246 }
247
248 static int FUNC(uncompressed_header)(CodedBitstreamContext *ctx, RWContext *rw,
249                                      VP9RawFrameHeader *current)
250 {
251     int profile, i;
252     int err;
253
254     f(2, frame_marker);
255
256     f(1, profile_low_bit);
257     f(1, profile_high_bit);
258     profile = (current->profile_high_bit << 1) + current->profile_low_bit;
259     if (profile == 3)
260         f(1, profile_reserved_zero);
261
262     f(1, show_existing_frame);
263     if (current->show_existing_frame) {
264         f(3, frame_to_show_map_idx);
265         infer(header_size_in_bytes, 0);
266         infer(refresh_frame_flags,  0x00);
267         infer(loop_filter_level,    0);
268         return 0;
269     }
270
271     f(1, frame_type);
272     f(1, show_frame);
273     f(1, error_resilient_mode);
274
275     if (current->frame_type == VP9_KEY_FRAME) {
276         CHECK(FUNC(frame_sync_code)(ctx, rw, current));
277         CHECK(FUNC(color_config)(ctx, rw, current, profile));
278         CHECK(FUNC(frame_size)(ctx, rw, current));
279         CHECK(FUNC(render_size)(ctx, rw, current));
280
281         infer(refresh_frame_flags, 0xff);
282
283     } else {
284          if (current->show_frame == 0)
285              f(1, intra_only);
286          else
287              infer(intra_only, 0);
288
289          if (current->error_resilient_mode == 0)
290              f(2, reset_frame_context);
291          else
292              infer(reset_frame_context, 0);
293
294          if (current->intra_only == 1) {
295              CHECK(FUNC(frame_sync_code)(ctx, rw, current));
296
297              if (profile > 0) {
298                  CHECK(FUNC(color_config)(ctx, rw, current, profile));
299              } else {
300                  infer(color_space,   1);
301                  infer(subsampling_x, 1);
302                  infer(subsampling_y, 1);
303              }
304
305              f(8, refresh_frame_flags);
306
307              CHECK(FUNC(frame_size)(ctx, rw, current));
308              CHECK(FUNC(render_size)(ctx, rw, current));
309          } else {
310              f(8, refresh_frame_flags);
311
312              for (i = 0; i < VP9_REFS_PER_FRAME; i++) {
313                  fs(3, ref_frame_idx[i], 1, i);
314                  fs(1, ref_frame_sign_bias[VP9_LAST_FRAME + i],
315                     1, VP9_LAST_FRAME + i);
316              }
317
318              CHECK(FUNC(frame_size_with_refs)(ctx, rw, current));
319              f(1, allow_high_precision_mv);
320              CHECK(FUNC(interpolation_filter)(ctx, rw, current));
321          }
322     }
323
324     if (current->error_resilient_mode == 0) {
325         f(1, refresh_frame_context);
326         f(1, frame_parallel_decoding_mode);
327     } else {
328         infer(refresh_frame_context,        0);
329         infer(frame_parallel_decoding_mode, 1);
330     }
331
332     f(2, frame_context_idx);
333
334     CHECK(FUNC(loop_filter_params)(ctx, rw, current));
335     CHECK(FUNC(quantization_params)(ctx, rw, current));
336     CHECK(FUNC(segmentation_params)(ctx, rw, current));
337     CHECK(FUNC(tile_info)(ctx, rw, current));
338
339     f(16, header_size_in_bytes);
340
341     return 0;
342 }
343
344 static int FUNC(trailing_bits)(CodedBitstreamContext *ctx, RWContext *rw)
345 {
346     int err;
347     av_unused int zero = 0;
348     while (byte_alignment(rw) != 0)
349         xf(1, zero_bit, zero, 0);
350
351     return 0;
352 }
353
354 static int FUNC(frame)(CodedBitstreamContext *ctx, RWContext *rw,
355                        VP9RawFrame *current)
356 {
357     int err;
358
359     HEADER("Frame");
360
361     CHECK(FUNC(uncompressed_header)(ctx, rw, &current->header));
362
363     CHECK(FUNC(trailing_bits)(ctx, rw));
364
365     return 0;
366 }
367
368 static int FUNC(superframe_index)(CodedBitstreamContext *ctx, RWContext *rw,
369                                   VP9RawSuperframeIndex *current)
370 {
371     int err, i;
372
373     HEADER("Superframe Index");
374
375     f(3, superframe_marker);
376     f(2, bytes_per_framesize_minus_1);
377     f(3, frames_in_superframe_minus_1);
378
379     for (i = 0; i <= current->frames_in_superframe_minus_1; i++) {
380         // Surprise little-endian!
381         fle(8 * (current->bytes_per_framesize_minus_1 + 1),
382             frame_sizes[i], 1, i);
383     }
384
385     f(3, superframe_marker);
386     f(2, bytes_per_framesize_minus_1);
387     f(3, frames_in_superframe_minus_1);
388
389     return 0;
390 }