1 /*
2 * H.265 video codec.
3 * Copyright (c) 2013-2014 struktur AG, Dirk Farin <farin@struktur.de>
4 *
5 * This file is part of libde265.
6 *
7 * libde265 is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as
9 * published by the Free Software Foundation, either version 3 of
10 * the License, or (at your option) any later version.
11 *
12 * libde265 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
15 * GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with libde265. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "pps.h"
22 #include "decctx.h"
23 #include "util.h"
24
25 #include <assert.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #if defined(_MSC_VER) || defined(__MINGW32__)
29 # include <malloc.h>
30 #elif defined(HAVE_ALLOCA_H)
31 # include <alloca.h>
32 #endif
33
34
reset()35 void pps_range_extension::reset()
36 {
37 log2_max_transform_skip_block_size = 2;
38 cross_component_prediction_enabled_flag = false;
39 chroma_qp_offset_list_enabled_flag = false;
40 diff_cu_chroma_qp_offset_depth = 0;
41 chroma_qp_offset_list_len = 0;
42 log2_sao_offset_scale_luma = 0;
43 log2_sao_offset_scale_chroma = 0;
44 }
45
46
read(bitreader * br,decoder_context * ctx,const pic_parameter_set * pps)47 bool pps_range_extension::read(bitreader* br, decoder_context* ctx, const pic_parameter_set* pps)
48 {
49 const seq_parameter_set* sps = ctx->get_sps(pps->seq_parameter_set_id);
50
51 int uvlc;
52
53 if (pps->transform_skip_enabled_flag) {
54 uvlc = get_uvlc(br);
55 if (uvlc == UVLC_ERROR ||
56 uvlc+2 > sps->Log2MaxTrafoSize) {
57
58 // Note: this is out of spec, but the conformance stream
59 // PERSIST_RPARAM_A_RExt_Sony_2 codes a too large value.
60
61 //ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
62 //return false;
63 }
64
65 log2_max_transform_skip_block_size = uvlc+2;
66 }
67
68 cross_component_prediction_enabled_flag = get_bits(br,1);
69 if (sps->ChromaArrayType != CHROMA_444 &&
70 cross_component_prediction_enabled_flag) {
71 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
72 }
73
74 chroma_qp_offset_list_enabled_flag = get_bits(br,1);
75 if (sps->ChromaArrayType == CHROMA_MONO &&
76 chroma_qp_offset_list_enabled_flag) {
77 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
78 }
79
80 if (chroma_qp_offset_list_enabled_flag) {
81 uvlc = get_uvlc(br);
82 if (uvlc == UVLC_ERROR ||
83 uvlc > sps->log2_diff_max_min_luma_coding_block_size) {
84 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
85 return false;
86 }
87
88 diff_cu_chroma_qp_offset_depth = uvlc;
89
90
91 uvlc = get_uvlc(br);
92 if (uvlc == UVLC_ERROR ||
93 uvlc > 5) {
94 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
95 return false;
96 }
97
98 chroma_qp_offset_list_len = uvlc+1;
99
100 for (int i=0;i<chroma_qp_offset_list_len;i++) {
101 int svlc;
102 svlc = get_svlc(br);
103 if (svlc == UVLC_ERROR ||
104 svlc < -12 || svlc > 12) {
105 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
106 return false;
107 }
108
109 cb_qp_offset_list[i] = svlc;
110
111 svlc = get_svlc(br);
112 if (svlc == UVLC_ERROR ||
113 svlc < -12 || svlc > 12) {
114 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
115 return false;
116 }
117
118 cr_qp_offset_list[i] = svlc;
119 }
120 }
121
122
123 uvlc = get_uvlc(br);
124 if (uvlc == UVLC_ERROR ||
125 uvlc > libde265_max(0, sps->BitDepth_Y-10)) {
126 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
127 return false;
128 }
129
130 log2_sao_offset_scale_luma = uvlc;
131
132 uvlc = get_uvlc(br);
133 if (uvlc == UVLC_ERROR ||
134 uvlc > libde265_max(0, sps->BitDepth_C-10)) {
135 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
136 return false;
137 }
138
139 log2_sao_offset_scale_chroma = uvlc;
140
141 return true;
142 }
143
144
dump(int fd) const145 void pps_range_extension::dump(int fd) const
146 {
147 FILE* fh;
148 if (fd==1) fh=stdout;
149 else if (fd==2) fh=stderr;
150 else { return; }
151
152 #define LOG0(t) log2fh(fh, t)
153 #define LOG1(t,d) log2fh(fh, t,d)
154 #define LOG2(t,d,e) log2fh(fh, t,d,e)
155
156 LOG0("---------- PPS range-extension ----------\n");
157 LOG1("log2_max_transform_skip_block_size : %d\n", log2_max_transform_skip_block_size);
158 LOG1("cross_component_prediction_enabled_flag : %d\n", cross_component_prediction_enabled_flag);
159 LOG1("chroma_qp_offset_list_enabled_flag : %d\n", chroma_qp_offset_list_enabled_flag);
160 if (chroma_qp_offset_list_enabled_flag) {
161 LOG1("diff_cu_chroma_qp_offset_depth : %d\n", diff_cu_chroma_qp_offset_depth);
162 LOG1("chroma_qp_offset_list_len : %d\n", chroma_qp_offset_list_len);
163 for (int i=0;i<chroma_qp_offset_list_len;i++) {
164 LOG2("cb_qp_offset_list[%d] : %d\n", i,cb_qp_offset_list[i]);
165 LOG2("cr_qp_offset_list[%d] : %d\n", i,cr_qp_offset_list[i]);
166 }
167 }
168
169 LOG1("log2_sao_offset_scale_luma : %d\n", log2_sao_offset_scale_luma);
170 LOG1("log2_sao_offset_scale_chroma : %d\n", log2_sao_offset_scale_chroma);
171 #undef LOG2
172 #undef LOG1
173 #undef LOG0
174 }
175
176
177
178
179
pic_parameter_set()180 pic_parameter_set::pic_parameter_set()
181 {
182 reset();
183 }
184
185
~pic_parameter_set()186 pic_parameter_set::~pic_parameter_set()
187 {
188 }
189
190
set_defaults(enum PresetSet)191 void pic_parameter_set::set_defaults(enum PresetSet)
192 {
193 pps_read = false;
194 sps = NULL;
195
196 pic_parameter_set_id = 0;
197 seq_parameter_set_id = 0;
198 dependent_slice_segments_enabled_flag = 0;
199 sign_data_hiding_flag = 0;
200 cabac_init_present_flag = 0;
201 num_ref_idx_l0_default_active = 1;
202 num_ref_idx_l1_default_active = 1;
203
204 pic_init_qp = 27;
205 constrained_intra_pred_flag = 0;
206 transform_skip_enabled_flag = 0;
207
208 cu_qp_delta_enabled_flag = 0;
209 diff_cu_qp_delta_depth = 0;
210
211 pic_cb_qp_offset = 0;
212 pic_cr_qp_offset = 0;
213 pps_slice_chroma_qp_offsets_present_flag = 0;
214 weighted_pred_flag = 0;
215 weighted_bipred_flag= 0;
216 output_flag_present_flag = 0;
217 transquant_bypass_enable_flag = 0;
218 entropy_coding_sync_enabled_flag = 0;
219
220 // --- tiles ---
221
222 tiles_enabled_flag = 0;
223 num_tile_columns = 1;
224 num_tile_rows = 1;
225 uniform_spacing_flag = 1;
226
227
228 // --- ---
229
230 loop_filter_across_tiles_enabled_flag = 1;
231 pps_loop_filter_across_slices_enabled_flag = 1;
232
233 for (int i=0;i<DE265_MAX_TILE_COLUMNS;i++) { colWidth[i]=0; }
234 for (int i=0;i<DE265_MAX_TILE_ROWS;i++) { rowHeight[i]=0; }
235 for (int i=0;i<=DE265_MAX_TILE_COLUMNS;i++) { colBd[i]=0; }
236 for (int i=0;i<=DE265_MAX_TILE_ROWS;i++) { rowBd[i]=0; }
237
238 CtbAddrRStoTS.clear();
239 CtbAddrTStoRS.clear();
240 TileId.clear();
241 TileIdRS.clear();
242 MinTbAddrZS.clear();
243
244
245 Log2MinCuQpDeltaSize = 0;
246
247 deblocking_filter_control_present_flag = 0;
248 deblocking_filter_override_enabled_flag = 0;
249 pic_disable_deblocking_filter_flag = 0;
250
251 beta_offset = 0;
252 tc_offset = 0;
253
254 pic_scaling_list_data_present_flag = 0;
255 // TODO struct scaling_list_data scaling_list;
256
257 lists_modification_present_flag = 0;
258 log2_parallel_merge_level = 2;
259
260 num_extra_slice_header_bits = 0;
261 slice_segment_header_extension_present_flag = 0;
262 pps_extension_flag = 0;
263
264 pps_range_extension_flag = 0;
265 pps_multilayer_extension_flag = 0;
266 pps_extension_6bits = 0;
267 }
268
269
read(bitreader * br,decoder_context * ctx)270 bool pic_parameter_set::read(bitreader* br, decoder_context* ctx)
271 {
272 reset();
273
274
275 int uvlc;
276 pic_parameter_set_id = uvlc = get_uvlc(br);
277 if (uvlc >= DE265_MAX_PPS_SETS ||
278 uvlc == UVLC_ERROR) {
279 ctx->add_warning(DE265_WARNING_NONEXISTING_PPS_REFERENCED, false);
280 return false;
281 }
282
283 seq_parameter_set_id = uvlc = get_uvlc(br);
284 if (uvlc >= DE265_MAX_SPS_SETS ||
285 uvlc == UVLC_ERROR) {
286 ctx->add_warning(DE265_WARNING_NONEXISTING_SPS_REFERENCED, false);
287 return false;
288 }
289
290 dependent_slice_segments_enabled_flag = get_bits(br,1);
291 output_flag_present_flag = get_bits(br,1);
292 num_extra_slice_header_bits = get_bits(br,3);
293 sign_data_hiding_flag = get_bits(br,1);
294 cabac_init_present_flag = get_bits(br,1);
295 num_ref_idx_l0_default_active = uvlc = get_uvlc(br);
296 if (uvlc == UVLC_ERROR) {
297 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
298 return false;
299 }
300 num_ref_idx_l0_default_active++;
301
302 num_ref_idx_l1_default_active = uvlc = get_uvlc(br);
303 if (uvlc == UVLC_ERROR) {
304 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
305 return false;
306 }
307 num_ref_idx_l1_default_active++;
308
309
310 if (!ctx->has_sps(seq_parameter_set_id)) {
311 ctx->add_warning(DE265_WARNING_NONEXISTING_SPS_REFERENCED, false);
312 return false;
313 }
314
315 sps = ctx->get_shared_sps(seq_parameter_set_id);
316
317 if ((pic_init_qp = get_svlc(br)) == UVLC_ERROR) {
318 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
319 return false;
320 }
321 pic_init_qp += 26;
322
323 constrained_intra_pred_flag = get_bits(br,1);
324 transform_skip_enabled_flag = get_bits(br,1);
325 cu_qp_delta_enabled_flag = get_bits(br,1);
326
327 if (cu_qp_delta_enabled_flag) {
328 if ((diff_cu_qp_delta_depth = get_uvlc(br)) == UVLC_ERROR) {
329 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
330 return false;
331 }
332 } else {
333 diff_cu_qp_delta_depth = 0;
334 }
335
336 if ((pic_cb_qp_offset = get_svlc(br)) == UVLC_ERROR) {
337 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
338 return false;
339 }
340
341 if ((pic_cr_qp_offset = get_svlc(br)) == UVLC_ERROR) {
342 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
343 return false;
344 }
345
346 pps_slice_chroma_qp_offsets_present_flag = get_bits(br,1);
347 weighted_pred_flag = get_bits(br,1);
348 weighted_bipred_flag = get_bits(br,1);
349 transquant_bypass_enable_flag = get_bits(br,1);
350 tiles_enabled_flag = get_bits(br,1);
351 entropy_coding_sync_enabled_flag = get_bits(br,1);
352
353
354 // --- tiles ---
355
356 if (tiles_enabled_flag) {
357 num_tile_columns = get_uvlc(br);
358 if (num_tile_columns == UVLC_ERROR ||
359 num_tile_columns+1 > DE265_MAX_TILE_COLUMNS) {
360 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
361 return false;
362 }
363 num_tile_columns++;
364
365 num_tile_rows = get_uvlc(br);
366 if (num_tile_rows == UVLC_ERROR ||
367 num_tile_rows+1 > DE265_MAX_TILE_ROWS) {
368 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
369 return false;
370 }
371 num_tile_rows++;
372
373 uniform_spacing_flag = get_bits(br,1);
374
375 if (uniform_spacing_flag==false) {
376 int lastColumnWidth = sps->PicWidthInCtbsY;
377 int lastRowHeight = sps->PicHeightInCtbsY;
378
379 for (int i=0; i<num_tile_columns-1; i++)
380 {
381 colWidth[i] = get_uvlc(br);
382 if (colWidth[i] == UVLC_ERROR) {
383 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
384 return false;
385 }
386 colWidth[i]++;
387
388 lastColumnWidth -= colWidth[i];
389 }
390
391 if (lastColumnWidth <= 0) {
392 return false;
393 }
394
395 colWidth[num_tile_columns-1] = lastColumnWidth;
396
397 for (int i=0; i<num_tile_rows-1; i++)
398 {
399 rowHeight[i] = get_uvlc(br);
400 if (rowHeight[i] == UVLC_ERROR) {
401 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
402 return false;
403 }
404 rowHeight[i]++;
405 lastRowHeight -= rowHeight[i];
406 }
407
408 if (lastRowHeight <= 0) {
409 return false;
410 }
411
412
413 rowHeight[num_tile_rows-1] = lastRowHeight;
414 }
415
416 loop_filter_across_tiles_enabled_flag = get_bits(br,1);
417
418 } else {
419 num_tile_columns = 1;
420 num_tile_rows = 1;
421 uniform_spacing_flag = 1;
422 loop_filter_across_tiles_enabled_flag = 0;
423 }
424
425
426
427 // END tiles
428
429
430
431 beta_offset = 0; // default value
432 tc_offset = 0; // default value
433
434 pps_loop_filter_across_slices_enabled_flag = get_bits(br,1);
435 deblocking_filter_control_present_flag = get_bits(br,1);
436 if (deblocking_filter_control_present_flag) {
437 deblocking_filter_override_enabled_flag = get_bits(br,1);
438 pic_disable_deblocking_filter_flag = get_bits(br,1);
439 if (!pic_disable_deblocking_filter_flag) {
440 beta_offset = get_svlc(br);
441 if (beta_offset == UVLC_ERROR) {
442 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
443 return false;
444 }
445 beta_offset *= 2;
446
447 tc_offset = get_svlc(br);
448 if (tc_offset == UVLC_ERROR) {
449 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
450 return false;
451 }
452 tc_offset *= 2;
453 }
454 }
455 else {
456 deblocking_filter_override_enabled_flag = 0;
457 pic_disable_deblocking_filter_flag = 0;
458 }
459
460
461 // --- scaling list ---
462
463 pic_scaling_list_data_present_flag = get_bits(br,1);
464
465 // check consistency: if scaling-lists are not enabled, pic_scalign_list_data_present_flag
466 // must be FALSE
467 if (sps->scaling_list_enable_flag==0 &&
468 pic_scaling_list_data_present_flag != 0) {
469 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
470 return false;
471 }
472
473 if (pic_scaling_list_data_present_flag) {
474 de265_error err = read_scaling_list(br, sps.get(), &scaling_list, true);
475 if (err != DE265_OK) {
476 ctx->add_warning(err, false);
477 return false;
478 }
479 }
480 else {
481 memcpy(&scaling_list, &sps->scaling_list, sizeof(scaling_list_data));
482 }
483
484
485
486
487 lists_modification_present_flag = get_bits(br,1);
488 log2_parallel_merge_level = get_uvlc(br);
489 if (log2_parallel_merge_level == UVLC_ERROR) {
490 ctx->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
491 return false;
492 }
493 log2_parallel_merge_level += 2;
494
495 if (log2_parallel_merge_level-2 > sps->log2_min_luma_coding_block_size-3 +1 +
496 sps->log2_diff_max_min_luma_coding_block_size) {
497 return false;
498 }
499
500 slice_segment_header_extension_present_flag = get_bits(br,1);
501 pps_extension_flag = get_bits(br,1);
502
503 if (pps_extension_flag) {
504 pps_range_extension_flag = get_bits(br,1);
505 pps_multilayer_extension_flag = get_bits(br,1);
506 pps_extension_6bits = get_bits(br,6);
507
508 if (pps_range_extension_flag) {
509 bool success = range_extension.read(br, ctx, this);
510 if (!success) {
511 return false;
512 }
513 }
514
515 //assert(false);
516 /*
517 while( more_rbsp_data() )
518
519 pps_extension_data_flag
520 u(1)
521 rbsp_trailing_bits()
522
523 }
524 */
525 }
526
527
528 set_derived_values(sps.get());
529
530 pps_read = true;
531
532 return true;
533 }
534
535
set_derived_values(const seq_parameter_set * sps)536 void pic_parameter_set::set_derived_values(const seq_parameter_set* sps)
537 {
538 Log2MinCuQpDeltaSize = sps->Log2CtbSizeY - diff_cu_qp_delta_depth;
539
540 Log2MinCuChromaQpOffsetSize = sps->Log2CtbSizeY - range_extension.diff_cu_chroma_qp_offset_depth;
541 Log2MaxTransformSkipSize = range_extension.log2_max_transform_skip_block_size;
542
543 if (uniform_spacing_flag) {
544
545 // set columns widths
546
547 int *const colPos = (int *)alloca((num_tile_columns+1) * sizeof(int));
548
549 for (int i=0;i<=num_tile_columns;i++) {
550 colPos[i] = i*sps->PicWidthInCtbsY / num_tile_columns;
551 }
552 for (int i=0;i<num_tile_columns;i++) {
553 colWidth[i] = colPos[i+1] - colPos[i];
554 }
555
556 // set row heights
557
558 int *const rowPos = (int *)alloca((num_tile_rows+1) * sizeof(int));
559
560 for (int i=0;i<=num_tile_rows;i++) {
561 rowPos[i] = i*sps->PicHeightInCtbsY / num_tile_rows;
562 }
563 for (int i=0;i<num_tile_rows;i++) {
564 rowHeight[i] = rowPos[i+1] - rowPos[i];
565 }
566 }
567
568
569 // set tile boundaries
570
571 colBd[0]=0;
572 for (int i=0;i<num_tile_columns;i++) {
573 colBd[i+1] = colBd[i] + colWidth[i];
574 }
575
576 rowBd[0]=0;
577 for (int i=0;i<num_tile_rows;i++) {
578 rowBd[i+1] = rowBd[i] + rowHeight[i];
579 }
580
581
582
583 // alloc raster scan arrays
584
585 CtbAddrRStoTS.resize(sps->PicSizeInCtbsY);
586 CtbAddrTStoRS.resize(sps->PicSizeInCtbsY);
587 TileId .resize(sps->PicSizeInCtbsY);
588 TileIdRS .resize(sps->PicSizeInCtbsY);
589 MinTbAddrZS .resize(sps->PicSizeInTbsY );
590
591
592 // raster scan (RS) <-> tile scan (TS) conversion
593
594 for (int ctbAddrRS=0 ; ctbAddrRS < sps->PicSizeInCtbsY ; ctbAddrRS++)
595 {
596 int tbX = ctbAddrRS % sps->PicWidthInCtbsY;
597 int tbY = ctbAddrRS / sps->PicWidthInCtbsY;
598 int tileX=-1,tileY=-1;
599
600 for (int i=0;i<num_tile_columns;i++)
601 if (tbX >= colBd[i])
602 tileX=i;
603
604 for (int j=0;j<num_tile_rows;j++)
605 if (tbY >= rowBd[j])
606 tileY=j;
607
608 CtbAddrRStoTS[ctbAddrRS] = 0;
609 for (int i=0;i<tileX;i++)
610 CtbAddrRStoTS[ctbAddrRS] += rowHeight[tileY]*colWidth[i];
611
612 for (int j=0;j<tileY;j++)
613 {
614 //pps->CtbAddrRStoTS[ctbAddrRS] += (tbY - pps->rowBd[tileY])*pps->colWidth[tileX];
615 //pps->CtbAddrRStoTS[ctbAddrRS] += tbX - pps->colBd[tileX];
616
617 CtbAddrRStoTS[ctbAddrRS] += sps->PicWidthInCtbsY * rowHeight[j];
618 }
619
620 assert(tileX>=0 && tileY>=0);
621
622 CtbAddrRStoTS[ctbAddrRS] += (tbY-rowBd[tileY])*colWidth[tileX];
623 CtbAddrRStoTS[ctbAddrRS] += tbX - colBd[tileX];
624
625
626 // inverse mapping
627
628 CtbAddrTStoRS[ CtbAddrRStoTS[ctbAddrRS] ] = ctbAddrRS;
629 }
630
631
632 #if 0
633 logtrace(LogHeaders,"6.5.1 CtbAddrRSToTS\n");
634 for (int y=0;y<sps->PicHeightInCtbsY;y++)
635 {
636 for (int x=0;x<sps->PicWidthInCtbsY;x++)
637 {
638 logtrace(LogHeaders,"%3d ", CtbAddrRStoTS[x + y*sps->PicWidthInCtbsY]);
639 }
640
641 logtrace(LogHeaders,"\n");
642 }
643 #endif
644
645 // tile id
646
647 for (int j=0, tIdx=0 ; j<num_tile_rows ; j++)
648 for (int i=0 ; i<num_tile_columns;i++)
649 {
650 for (int y=rowBd[j] ; y<rowBd[j+1] ; y++)
651 for (int x=colBd[i] ; x<colBd[i+1] ; x++) {
652 TileId [ CtbAddrRStoTS[y*sps->PicWidthInCtbsY + x] ] = tIdx;
653 TileIdRS[ y*sps->PicWidthInCtbsY + x ] = tIdx;
654
655 //logtrace(LogHeaders,"tileID[%d,%d] = %d\n",x,y,pps->TileIdRS[ y*sps->PicWidthInCtbsY + x ]);
656 }
657
658 tIdx++;
659 }
660
661 #if 0
662 logtrace(LogHeaders,"Tile IDs RS:\n");
663 for (int y=0;y<sps->PicHeightInCtbsY;y++) {
664 for (int x=0;x<sps->PicWidthInCtbsY;x++) {
665 logtrace(LogHeaders,"%2d ",TileIdRS[y*sps->PicWidthInCtbsY+x]);
666 }
667 logtrace(LogHeaders,"\n");
668 }
669 #endif
670
671 // 6.5.2 Z-scan order array initialization process
672
673 for (int y=0;y<sps->PicHeightInTbsY;y++)
674 for (int x=0;x<sps->PicWidthInTbsY;x++)
675 {
676 int tbX = (x<<sps->Log2MinTrafoSize)>>sps->Log2CtbSizeY;
677 int tbY = (y<<sps->Log2MinTrafoSize)>>sps->Log2CtbSizeY;
678 int ctbAddrRS = sps->PicWidthInCtbsY*tbY + tbX;
679
680 MinTbAddrZS[x + y*sps->PicWidthInTbsY] = CtbAddrRStoTS[ctbAddrRS]
681 << ((sps->Log2CtbSizeY-sps->Log2MinTrafoSize)*2);
682
683 int p=0;
684 for (int i=0 ; i<(sps->Log2CtbSizeY - sps->Log2MinTrafoSize) ; i++) {
685 int m=1<<i;
686 p += (m & x ? m*m : 0) + (m & y ? 2*m*m : 0);
687 }
688
689 MinTbAddrZS[x + y*sps->PicWidthInTbsY] += p;
690 }
691
692
693 // --- debug logging ---
694
695 /*
696 logtrace(LogHeaders,"6.5.2 Z-scan order array\n");
697 for (int y=0;y<sps->PicHeightInTbsY;y++)
698 {
699 for (int x=0;x<sps->PicWidthInTbsY;x++)
700 {
701 logtrace(LogHeaders,"%4d ", pps->MinTbAddrZS[x + y*sps->PicWidthInTbsY]);
702 }
703
704 logtrace(LogHeaders,"\n");
705 }
706
707 for (int i=0;i<sps->PicSizeInTbsY;i++)
708 {
709 for (int y=0;y<sps->PicHeightInTbsY;y++)
710 {
711 for (int x=0;x<sps->PicWidthInTbsY;x++)
712 {
713 if (pps->MinTbAddrZS[x + y*sps->PicWidthInTbsY] == i) {
714 logtrace(LogHeaders,"%d %d\n",x,y);
715 }
716 }
717 }
718 }
719 */
720 }
721
722
write(error_queue * errqueue,CABAC_encoder & out,const seq_parameter_set * sps)723 bool pic_parameter_set::write(error_queue* errqueue, CABAC_encoder& out,
724 const seq_parameter_set* sps)
725 {
726 if (pic_parameter_set_id >= DE265_MAX_PPS_SETS) {
727 errqueue->add_warning(DE265_WARNING_NONEXISTING_PPS_REFERENCED, false);
728 return false;
729 }
730 out.write_uvlc(pic_parameter_set_id);
731
732 if (seq_parameter_set_id >= DE265_MAX_PPS_SETS) {
733 errqueue->add_warning(DE265_WARNING_NONEXISTING_SPS_REFERENCED, false);
734 return false;
735 }
736 out.write_uvlc(seq_parameter_set_id);
737
738 out.write_bit(dependent_slice_segments_enabled_flag);
739 out.write_bit(output_flag_present_flag);
740 out.write_bits(num_extra_slice_header_bits,3);
741 out.write_bit(sign_data_hiding_flag);
742 out.write_bit(cabac_init_present_flag);
743 out.write_uvlc(num_ref_idx_l0_default_active-1);
744 out.write_uvlc(num_ref_idx_l1_default_active-1);
745
746 out.write_svlc(pic_init_qp-26);
747
748 out.write_bit(constrained_intra_pred_flag);
749 out.write_bit(transform_skip_enabled_flag);
750 out.write_bit(cu_qp_delta_enabled_flag);
751
752 if (cu_qp_delta_enabled_flag) {
753 out.write_uvlc(diff_cu_qp_delta_depth);
754 }
755
756 out.write_svlc(pic_cb_qp_offset);
757 out.write_svlc(pic_cr_qp_offset);
758
759 out.write_bit(pps_slice_chroma_qp_offsets_present_flag);
760 out.write_bit(weighted_pred_flag);
761 out.write_bit(weighted_bipred_flag);
762 out.write_bit(transquant_bypass_enable_flag);
763 out.write_bit(tiles_enabled_flag);
764 out.write_bit(entropy_coding_sync_enabled_flag);
765
766
767 // --- tiles ---
768
769 if (tiles_enabled_flag) {
770 if (num_tile_columns > DE265_MAX_TILE_COLUMNS) {
771 errqueue->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
772 return false;
773 }
774 out.write_uvlc(num_tile_columns-1);
775
776 if (num_tile_rows > DE265_MAX_TILE_ROWS) {
777 errqueue->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
778 return false;
779 }
780 out.write_uvlc(num_tile_rows-1);
781
782 out.write_bit(uniform_spacing_flag);
783
784 if (uniform_spacing_flag==false) {
785 for (int i=0; i<num_tile_columns-1; i++)
786 {
787 out.write_uvlc(colWidth[i]-1);
788 }
789
790 for (int i=0; i<num_tile_rows-1; i++)
791 {
792 out.write_uvlc(rowHeight[i]-1);
793 }
794 }
795
796 out.write_bit(loop_filter_across_tiles_enabled_flag);
797 }
798
799
800 out.write_bit(pps_loop_filter_across_slices_enabled_flag);
801 out.write_bit(deblocking_filter_control_present_flag);
802
803 if (deblocking_filter_control_present_flag) {
804 out.write_bit(deblocking_filter_override_enabled_flag);
805 out.write_bit(pic_disable_deblocking_filter_flag);
806
807 if (!pic_disable_deblocking_filter_flag) {
808 out.write_svlc(beta_offset/2);
809 out.write_svlc(tc_offset /2);
810 }
811 }
812
813
814 // --- scaling list ---
815
816 out.write_bit(pic_scaling_list_data_present_flag);
817
818 // check consistency: if scaling-lists are not enabled, pic_scalign_list_data_present_flag
819 // must be FALSE
820 if (sps->scaling_list_enable_flag==0 &&
821 pic_scaling_list_data_present_flag != 0) {
822 errqueue->add_warning(DE265_WARNING_PPS_HEADER_INVALID, false);
823 return false;
824 }
825
826 if (pic_scaling_list_data_present_flag) {
827 de265_error err = write_scaling_list(out, sps, &scaling_list, true);
828 if (err != DE265_OK) {
829 errqueue->add_warning(err, false);
830 return false;
831 }
832 }
833
834
835
836 out.write_bit(lists_modification_present_flag);
837 out.write_uvlc(log2_parallel_merge_level-2);
838
839 out.write_bit(slice_segment_header_extension_present_flag);
840 out.write_bit(pps_extension_flag);
841
842 if (pps_extension_flag) {
843 //assert(false);
844 /*
845 while( more_rbsp_data() )
846
847 pps_extension_data_flag
848 u(1)
849 rbsp_trailing_bits()
850
851 }
852 */
853 }
854
855
856 pps_read = true;
857
858 return true;
859 }
860
861
dump(int fd) const862 void pic_parameter_set::dump(int fd) const
863 {
864 FILE* fh;
865 if (fd==1) fh=stdout;
866 else if (fd==2) fh=stderr;
867 else { return; }
868
869 #define LOG0(t) log2fh(fh, t)
870 #define LOG1(t,d) log2fh(fh, t,d)
871
872 LOG0("----------------- PPS -----------------\n");
873 LOG1("pic_parameter_set_id : %d\n", pic_parameter_set_id);
874 LOG1("seq_parameter_set_id : %d\n", seq_parameter_set_id);
875 LOG1("dependent_slice_segments_enabled_flag : %d\n", dependent_slice_segments_enabled_flag);
876 LOG1("sign_data_hiding_flag : %d\n", sign_data_hiding_flag);
877 LOG1("cabac_init_present_flag : %d\n", cabac_init_present_flag);
878 LOG1("num_ref_idx_l0_default_active : %d\n", num_ref_idx_l0_default_active);
879 LOG1("num_ref_idx_l1_default_active : %d\n", num_ref_idx_l1_default_active);
880
881 LOG1("pic_init_qp : %d\n", pic_init_qp);
882 LOG1("constrained_intra_pred_flag: %d\n", constrained_intra_pred_flag);
883 LOG1("transform_skip_enabled_flag: %d\n", transform_skip_enabled_flag);
884 LOG1("cu_qp_delta_enabled_flag : %d\n", cu_qp_delta_enabled_flag);
885
886 if (cu_qp_delta_enabled_flag) {
887 LOG1("diff_cu_qp_delta_depth : %d\n", diff_cu_qp_delta_depth);
888 }
889
890 LOG1("pic_cb_qp_offset : %d\n", pic_cb_qp_offset);
891 LOG1("pic_cr_qp_offset : %d\n", pic_cr_qp_offset);
892 LOG1("pps_slice_chroma_qp_offsets_present_flag : %d\n", pps_slice_chroma_qp_offsets_present_flag);
893 LOG1("weighted_pred_flag : %d\n", weighted_pred_flag);
894 LOG1("weighted_bipred_flag : %d\n", weighted_bipred_flag);
895 LOG1("output_flag_present_flag : %d\n", output_flag_present_flag);
896 LOG1("transquant_bypass_enable_flag: %d\n", transquant_bypass_enable_flag);
897 LOG1("tiles_enabled_flag : %d\n", tiles_enabled_flag);
898 LOG1("entropy_coding_sync_enabled_flag: %d\n", entropy_coding_sync_enabled_flag);
899
900 if (tiles_enabled_flag) {
901 LOG1("num_tile_columns : %d\n", num_tile_columns);
902 LOG1("num_tile_rows : %d\n", num_tile_rows);
903 LOG1("uniform_spacing_flag: %d\n", uniform_spacing_flag);
904
905 LOG0("tile column boundaries: ");
906 for (int i=0;i<=num_tile_columns;i++) {
907 LOG1("*%d ",colBd[i]);
908 }
909 LOG0("*\n");
910
911 LOG0("tile row boundaries: ");
912 for (int i=0;i<=num_tile_rows;i++) {
913 LOG1("*%d ",rowBd[i]);
914 }
915 LOG0("*\n");
916
917 //if( !uniform_spacing_flag ) {
918 /*
919 for( i = 0; i < num_tile_columns_minus1; i++ )
920
921 column_width_minus1[i]
922 ue(v)
923 for( i = 0; i < num_tile_rows_minus1; i++ )
924
925 row_height_minus1[i]
926 ue(v)
927 }
928 */
929
930 LOG1("loop_filter_across_tiles_enabled_flag : %d\n", loop_filter_across_tiles_enabled_flag);
931 }
932
933 LOG1("pps_loop_filter_across_slices_enabled_flag: %d\n", pps_loop_filter_across_slices_enabled_flag);
934 LOG1("deblocking_filter_control_present_flag: %d\n", deblocking_filter_control_present_flag);
935
936 if (deblocking_filter_control_present_flag) {
937 LOG1("deblocking_filter_override_enabled_flag: %d\n", deblocking_filter_override_enabled_flag);
938 LOG1("pic_disable_deblocking_filter_flag: %d\n", pic_disable_deblocking_filter_flag);
939
940 LOG1("beta_offset: %d\n", beta_offset);
941 LOG1("tc_offset: %d\n", tc_offset);
942 }
943
944 LOG1("pic_scaling_list_data_present_flag: %d\n", pic_scaling_list_data_present_flag);
945 if (pic_scaling_list_data_present_flag) {
946 //scaling_list_data()
947 }
948
949 LOG1("lists_modification_present_flag: %d\n", lists_modification_present_flag);
950 LOG1("log2_parallel_merge_level : %d\n", log2_parallel_merge_level);
951 LOG1("num_extra_slice_header_bits : %d\n", num_extra_slice_header_bits);
952 LOG1("slice_segment_header_extension_present_flag : %d\n", slice_segment_header_extension_present_flag);
953 LOG1("pps_extension_flag : %d\n", pps_extension_flag);
954 LOG1("pps_range_extension_flag : %d\n", pps_range_extension_flag);
955 LOG1("pps_multilayer_extension_flag : %d\n", pps_multilayer_extension_flag);
956 LOG1("pps_extension_6bits : %d\n", pps_extension_6bits);
957
958 LOG1("Log2MinCuQpDeltaSize : %d\n", Log2MinCuQpDeltaSize);
959 LOG1("Log2MinCuChromaQpOffsetSize (RExt) : %d\n", Log2MinCuChromaQpOffsetSize);
960 LOG1("Log2MaxTransformSkipSize (RExt) : %d\n", Log2MaxTransformSkipSize);
961
962 #undef LOG0
963 #undef LOG1
964
965
966 if (pps_range_extension_flag) {
967 range_extension.dump(fd);
968 }
969 }
970
971
is_tile_start_CTB(int ctbX,int ctbY) const972 bool pic_parameter_set::is_tile_start_CTB(int ctbX,int ctbY) const
973 {
974 // fast check
975 if (tiles_enabled_flag==0) {
976 return ctbX == 0 && ctbY == 0;
977 }
978
979 for (int i=0;i<num_tile_columns;i++)
980 if (colBd[i]==ctbX)
981 {
982 for (int k=0;k<num_tile_rows;k++)
983 if (rowBd[k]==ctbY)
984 {
985 return true;
986 }
987
988 return false;
989 }
990
991 return false;
992 }
993