codecparsers: h264: add gst_h264_parse_nalu_header() helper.
[vaapi:gstreamer-codecparsers.git] / gst-libs / gst / codecparsers / gsth264parser.c
1 /* Gstreamer
2  * Copyright (C) <2011> Intel Corporation
3  * Copyright (C) <2011> Collabora Ltd.
4  * Copyright (C) <2011> Thibault Saunier <thibault.saunier@collabora.com>
5  *
6  * Some bits C-c,C-v'ed and s/4/3 from h264parse and videoparsers/h264parse.c:
7  *    Copyright (C) <2010> Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
8  *    Copyright (C) <2010> Collabora Multimedia
9  *    Copyright (C) <2010> Nokia Corporation
10  *
11  *    (C) 2005 Michal Benes <michal.benes@itonis.tv>
12  *    (C) 2008 Wim Taymans <wim.taymans@gmail.com>
13  *
14  * This library is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU Library General Public
16  * License as published by the Free Software Foundation; either
17  * version 2 of the License, or (at your option) any later version.
18  *
19  * This library is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22  * Library General Public License for more details.
23  *
24  * You should have received a copy of the GNU Library General Public
25  * License along with this library; if not, write to the
26  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
27  * Boston, MA 02110-1301, USA.
28  */
29
30 /**
31  * SECTION:gsth264parser
32  * @short_description: Convenience library for h264 video
33  * bitstream parsing.
34  *
35  * It offers you bitstream parsing in AVC mode or not. To identify Nals in a bitstream and
36  * parse its headers, you should call:
37  * <itemizedlist>
38  *   <listitem>
39  *      #gst_h264_parser_identify_nalu to identify the following nalu in not AVC bitstreams
40  *   </listitem>
41  *   <listitem>
42  *      #gst_h264_parser_identify_nalu_avc to identify the nalu in AVC bitstreams
43  *   </listitem>
44  * </itemizedlist>
45  *
46  * Then, depending on the #GstH264NalUnitType of the newly parsed #GstH264NalUnit, you should
47  * call the differents functions to parse the structure:
48  * <itemizedlist>
49  *   <listitem>
50  *      From #GST_H264_NAL_SLICE to #GST_H264_NAL_SLICE_IDR: #gst_h264_parser_parse_slice_hdr
51  *   </listitem>
52  *   <listitem>
53  *      #GST_H264_NAL_SEI: #gst_h264_parser_parse_sei
54  *   </listitem>
55  *   <listitem>
56  *      #GST_H264_NAL_SPS: #gst_h264_parser_parse_sps
57  *   </listitem>
58  *   <listitem>
59  *      #GST_H264_NAL_PPS: #gst_h264_parser_parse_pps
60  *   </listitem>
61  *   <listitem>
62  *      Any other: #gst_h264_parser_parse_nal
63  *   </listitem>
64  * </itemizedlist>
65  *
66  * Note: You should always call gst_h264_parser_parse_nal if you don't actually need
67  * #GstH264NalUnitType to be parsed for your personnal use, in order to guarantee that the
68  * #GstH264NalParser is always up to date.
69  *
70  * For more details about the structures, look at the ITU-T H.264 and ISO/IEC 14496-10 – MPEG-4
71  * Part 10 specifications, you can download them from:
72  *
73  * <itemizedlist>
74  *   <listitem>
75  *     ITU-T H.264: http://www.itu.int/rec/T-REC-H.264
76  *   </listitem>
77  *   <listitem>
78  *     ISO/IEC 14496-10: http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=56538
79  *   </listitem>
80  * </itemizedlist>
81  */
82
83 #ifdef HAVE_CONFIG_H
84 #  include "config.h"
85 #endif
86
87 #include "nalutils.h"
88 #include "gsth264parser.h"
89
90 #include <gst/base/gstbytereader.h>
91 #include <gst/base/gstbitreader.h>
92 #include <string.h>
93
94 GST_DEBUG_CATEGORY (h264_parser_debug);
95 #define GST_CAT_DEFAULT h264_parser_debug
96
97 static gboolean initialized = FALSE;
98 #define INITIALIZE_DEBUG_CATEGORY \
99   if (!initialized) { \
100     GST_DEBUG_CATEGORY_INIT (h264_parser_debug, "codecparsers_h264", 0, \
101         "h264 parser library"); \
102     initialized = TRUE; \
103   }
104
105 /**** Default scaling_lists according to Table 7-2 *****/
106 static const guint8 default_4x4_intra[16] = {
107   6, 13, 13, 20, 20, 20, 28, 28, 28, 28, 32, 32,
108   32, 37, 37, 42
109 };
110
111 static const guint8 default_4x4_inter[16] = {
112   10, 14, 14, 20, 20, 20, 24, 24, 24, 24, 27, 27,
113   27, 30, 30, 34
114 };
115
116 static const guint8 default_8x8_intra[64] = {
117   6, 10, 10, 13, 11, 13, 16, 16, 16, 16, 18, 18,
118   18, 18, 18, 23, 23, 23, 23, 23, 23, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27,
119   27, 27, 27, 27, 27, 29, 29, 29, 29, 29, 29, 29, 31, 31, 31, 31, 31, 31, 33,
120   33, 33, 33, 33, 36, 36, 36, 36, 38, 38, 38, 40, 40, 42
121 };
122
123 static const guint8 default_8x8_inter[64] = {
124   9, 13, 13, 15, 13, 15, 17, 17, 17, 17, 19, 19,
125   19, 19, 19, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 24, 24, 24,
126   24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27, 27, 28,
127   28, 28, 28, 28, 30, 30, 30, 30, 32, 32, 32, 33, 33, 35
128 };
129
130 static const guint8 zigzag_8x8[64] = {
131   0, 1, 8, 16, 9, 2, 3, 10,
132   17, 24, 32, 25, 18, 11, 4, 5,
133   12, 19, 26, 33, 40, 48, 41, 34,
134   27, 20, 13, 6, 7, 14, 21, 28,
135   35, 42, 49, 56, 57, 50, 43, 36,
136   29, 22, 15, 23, 30, 37, 44, 51,
137   58, 59, 52, 45, 38, 31, 39, 46,
138   53, 60, 61, 54, 47, 55, 62, 63
139 };
140
141 static const guint8 zigzag_4x4[16] = {
142   0, 1, 4, 8,
143   5, 2, 3, 6,
144   9, 12, 13, 10,
145   7, 11, 14, 15,
146 };
147
148 typedef struct
149 {
150   guint par_n, par_d;
151 } PAR;
152
153 /* Table E-1 - Meaning of sample aspect ratio indicator (1..16) */
154 static PAR aspect_ratios[17] = {
155   {0, 0},
156   {1, 1},
157   {12, 11},
158   {10, 11},
159   {16, 11},
160   {40, 33},
161   {24, 11},
162   {20, 11},
163   {32, 11},
164   {80, 33},
165   {18, 11},
166   {15, 11},
167   {64, 33},
168   {160, 99},
169   {4, 3},
170   {3, 2},
171   {2, 1}
172 };
173
174 /*****  Utils ****/
175 #define EXTENDED_SAR 255
176
177 static GstH264SPS *
178 gst_h264_parser_get_sps (GstH264NalParser * nalparser, guint8 sps_id)
179 {
180   GstH264SPS *sps;
181
182   sps = &nalparser->sps[sps_id];
183
184   if (sps->valid)
185     return sps;
186
187   return NULL;
188 }
189
190 static GstH264PPS *
191 gst_h264_parser_get_pps (GstH264NalParser * nalparser, guint8 pps_id)
192 {
193   GstH264PPS *pps;
194
195   pps = &nalparser->pps[pps_id];
196
197   if (pps->valid)
198     return pps;
199
200   return NULL;
201 }
202
203 static gboolean
204 gst_h264_parse_nalu_header (GstH264NalUnit * nalu)
205 {
206   guint8 *data = nalu->data + nalu->offset;
207
208   if (nalu->size < 1)
209     return FALSE;
210
211   nalu->type = (data[0] & 0x1f);
212   nalu->ref_idc = (data[0] & 0x60) >> 5;
213   nalu->idr_pic_flag = (nalu->type == 5 ? 1 : 0);
214
215   GST_DEBUG ("Nal type %u, ref_idc %u", nalu->type, nalu->ref_idc);
216   return TRUE;
217 }
218
219 /****** Parsing functions *****/
220
221 static gboolean
222 gst_h264_parse_hrd_parameters (GstH264HRDParams * hrd, NalReader * nr)
223 {
224   guint sched_sel_idx;
225
226   GST_DEBUG ("parsing \"HRD Parameters\"");
227
228   READ_UE_ALLOWED (nr, hrd->cpb_cnt_minus1, 0, 31);
229   READ_UINT8 (nr, hrd->bit_rate_scale, 4);
230   READ_UINT8 (nr, hrd->cpb_size_scale, 4);
231
232   for (sched_sel_idx = 0; sched_sel_idx <= hrd->cpb_cnt_minus1; sched_sel_idx++) {
233     READ_UE (nr, hrd->bit_rate_value_minus1[sched_sel_idx]);
234     READ_UE (nr, hrd->cpb_size_value_minus1[sched_sel_idx]);
235     READ_UINT8 (nr, hrd->cbr_flag[sched_sel_idx], 1);
236   }
237
238   READ_UINT8 (nr, hrd->initial_cpb_removal_delay_length_minus1, 5);
239   READ_UINT8 (nr, hrd->cpb_removal_delay_length_minus1, 5);
240   READ_UINT8 (nr, hrd->dpb_output_delay_length_minus1, 5);
241   READ_UINT8 (nr, hrd->time_offset_length, 5);
242
243   return TRUE;
244
245 error:
246   GST_WARNING ("error parsing \"HRD Parameters\"");
247   return FALSE;
248 }
249
250 static gboolean
251 gst_h264_parse_vui_parameters (GstH264SPS * sps, NalReader * nr)
252 {
253   GstH264VUIParams *vui = &sps->vui_parameters;
254
255   GST_DEBUG ("parsing \"VUI Parameters\"");
256
257   /* set default values for fields that might not be present in the bitstream
258      and have valid defaults */
259   vui->aspect_ratio_idc = 0;
260   vui->video_format = 5;
261   vui->video_full_range_flag = 0;
262   vui->colour_primaries = 2;
263   vui->transfer_characteristics = 2;
264   vui->matrix_coefficients = 2;
265   vui->chroma_sample_loc_type_top_field = 0;
266   vui->chroma_sample_loc_type_bottom_field = 0;
267   vui->low_delay_hrd_flag = 0;
268   vui->par_n = 0;
269   vui->par_d = 0;
270
271   READ_UINT8 (nr, vui->aspect_ratio_info_present_flag, 1);
272   if (vui->aspect_ratio_info_present_flag) {
273     READ_UINT8 (nr, vui->aspect_ratio_idc, 8);
274     if (vui->aspect_ratio_idc == EXTENDED_SAR) {
275       READ_UINT16 (nr, vui->sar_width, 16);
276       READ_UINT16 (nr, vui->sar_height, 16);
277       vui->par_n = vui->sar_width;
278       vui->par_d = vui->sar_height;
279     } else if (vui->aspect_ratio_idc <= 16) {
280       vui->par_n = aspect_ratios[vui->aspect_ratio_idc].par_n;
281       vui->par_d = aspect_ratios[vui->aspect_ratio_idc].par_d;
282     }
283   }
284
285   READ_UINT8 (nr, vui->overscan_info_present_flag, 1);
286   if (vui->overscan_info_present_flag)
287     READ_UINT8 (nr, vui->overscan_appropriate_flag, 1);
288
289   READ_UINT8 (nr, vui->video_signal_type_present_flag, 1);
290   if (vui->video_signal_type_present_flag) {
291
292     READ_UINT8 (nr, vui->video_format, 3);
293     READ_UINT8 (nr, vui->video_full_range_flag, 1);
294     READ_UINT8 (nr, vui->colour_description_present_flag, 1);
295     if (vui->colour_description_present_flag) {
296       READ_UINT8 (nr, vui->colour_primaries, 8);
297       READ_UINT8 (nr, vui->transfer_characteristics, 8);
298       READ_UINT8 (nr, vui->matrix_coefficients, 8);
299     }
300   }
301
302   READ_UINT8 (nr, vui->chroma_loc_info_present_flag, 1);
303   if (vui->chroma_loc_info_present_flag) {
304     READ_UE_ALLOWED (nr, vui->chroma_sample_loc_type_top_field, 0, 5);
305     READ_UE_ALLOWED (nr, vui->chroma_sample_loc_type_bottom_field, 0, 5);
306   }
307
308   READ_UINT8 (nr, vui->timing_info_present_flag, 1);
309   if (vui->timing_info_present_flag) {
310     READ_UINT32 (nr, vui->num_units_in_tick, 32);
311     if (vui->num_units_in_tick == 0)
312       GST_WARNING ("num_units_in_tick = 0 detected in stream "
313           "(incompliant to H.264 E.2.1).");
314
315     READ_UINT32 (nr, vui->time_scale, 32);
316     if (vui->time_scale == 0)
317       GST_WARNING ("time_scale = 0 detected in stream "
318           "(incompliant to H.264 E.2.1).");
319
320     READ_UINT8 (nr, vui->fixed_frame_rate_flag, 1);
321   }
322
323   READ_UINT8 (nr, vui->nal_hrd_parameters_present_flag, 1);
324   if (vui->nal_hrd_parameters_present_flag) {
325     if (!gst_h264_parse_hrd_parameters (&vui->nal_hrd_parameters, nr))
326       goto error;
327   }
328
329   READ_UINT8 (nr, vui->vcl_hrd_parameters_present_flag, 1);
330   if (vui->vcl_hrd_parameters_present_flag) {
331     if (!gst_h264_parse_hrd_parameters (&vui->vcl_hrd_parameters, nr))
332       goto error;
333   }
334
335   if (vui->nal_hrd_parameters_present_flag ||
336       vui->vcl_hrd_parameters_present_flag)
337     READ_UINT8 (nr, vui->low_delay_hrd_flag, 1);
338
339   READ_UINT8 (nr, vui->pic_struct_present_flag, 1);
340   READ_UINT8 (nr, vui->bitstream_restriction_flag, 1);
341   if (vui->bitstream_restriction_flag) {
342     READ_UINT8 (nr, vui->motion_vectors_over_pic_boundaries_flag, 1);
343     READ_UE (nr, vui->max_bytes_per_pic_denom);
344     READ_UE_ALLOWED (nr, vui->max_bits_per_mb_denom, 0, 16);
345     READ_UE_ALLOWED (nr, vui->log2_max_mv_length_horizontal, 0, 16);
346     READ_UE_ALLOWED (nr, vui->log2_max_mv_length_vertical, 0, 16);
347     READ_UE (nr, vui->num_reorder_frames);
348     READ_UE (nr, vui->max_dec_frame_buffering);
349   }
350
351   return TRUE;
352
353 error:
354   GST_WARNING ("error parsing \"VUI Parameters\"");
355   return FALSE;
356 }
357
358 static gboolean
359 gst_h264_parser_parse_scaling_list (NalReader * nr,
360     guint8 scaling_lists_4x4[6][16], guint8 scaling_lists_8x8[6][64],
361     const guint8 fallback_4x4_inter[16], const guint8 fallback_4x4_intra[16],
362     const guint8 fallback_8x8_inter[64], const guint8 fallback_8x8_intra[64],
363     guint8 n_lists)
364 {
365   guint i;
366
367   GST_DEBUG ("parsing scaling lists");
368
369   for (i = 0; i < 12; i++) {
370     gboolean use_default = FALSE;
371
372     if (i < n_lists) {
373       guint8 scaling_list_present_flag;
374
375       READ_UINT8 (nr, scaling_list_present_flag, 1);
376       if (scaling_list_present_flag) {
377         guint8 *scaling_list;
378         guint size;
379         guint j;
380         guint8 last_scale, next_scale;
381
382         if (i < 6) {
383           scaling_list = scaling_lists_4x4[i];
384           size = 16;
385         } else {
386           scaling_list = scaling_lists_8x8[i - 6];
387           size = 64;
388         }
389
390         last_scale = 8;
391         next_scale = 8;
392         for (j = 0; j < size; j++) {
393           if (next_scale != 0) {
394             gint32 delta_scale;
395
396             READ_SE (nr, delta_scale);
397             next_scale = (last_scale + delta_scale) & 0xff;
398           }
399           if (j == 0 && next_scale == 0) {
400             use_default = TRUE;
401             break;
402           }
403           last_scale = scaling_list[j] =
404               (next_scale == 0) ? last_scale : next_scale;
405         }
406       } else
407         use_default = TRUE;
408     } else
409       use_default = TRUE;
410
411     if (use_default) {
412       switch (i) {
413         case 0:
414           memcpy (scaling_lists_4x4[0], fallback_4x4_intra, 16);
415           break;
416         case 1:
417           memcpy (scaling_lists_4x4[1], scaling_lists_4x4[0], 16);
418           break;
419         case 2:
420           memcpy (scaling_lists_4x4[2], scaling_lists_4x4[1], 16);
421           break;
422         case 3:
423           memcpy (scaling_lists_4x4[3], fallback_4x4_inter, 16);
424           break;
425         case 4:
426           memcpy (scaling_lists_4x4[4], scaling_lists_4x4[3], 16);
427           break;
428         case 5:
429           memcpy (scaling_lists_4x4[5], scaling_lists_4x4[4], 16);
430           break;
431         case 6:
432           memcpy (scaling_lists_8x8[0], fallback_8x8_intra, 64);
433           break;
434         case 7:
435           memcpy (scaling_lists_8x8[1], fallback_8x8_inter, 64);
436           break;
437         case 8:
438           memcpy (scaling_lists_8x8[2], scaling_lists_8x8[0], 64);
439           break;
440         case 9:
441           memcpy (scaling_lists_8x8[3], scaling_lists_8x8[1], 64);
442           break;
443         case 10:
444           memcpy (scaling_lists_8x8[4], scaling_lists_8x8[2], 64);
445           break;
446         case 11:
447           memcpy (scaling_lists_8x8[5], scaling_lists_8x8[3], 64);
448           break;
449
450         default:
451           break;
452       }
453     }
454   }
455
456   return TRUE;
457
458 error:
459   GST_WARNING ("error parsing scaling lists");
460   return FALSE;
461 }
462
463 static gboolean
464 slice_parse_ref_pic_list_modification_1 (GstH264SliceHdr * slice,
465     NalReader * nr, guint list)
466 {
467   GstH264RefPicListModification *entries;
468   guint8 *ref_pic_list_modification_flag, *n_ref_pic_list_modification;
469   guint32 modification_of_pic_nums_idc;
470   guint i = 0;
471
472   if (list == 0) {
473     entries = slice->ref_pic_list_modification_l0;
474     ref_pic_list_modification_flag = &slice->ref_pic_list_modification_flag_l0;
475     n_ref_pic_list_modification = &slice->n_ref_pic_list_modification_l0;
476   } else {
477     entries = slice->ref_pic_list_modification_l1;
478     ref_pic_list_modification_flag = &slice->ref_pic_list_modification_flag_l1;
479     n_ref_pic_list_modification = &slice->n_ref_pic_list_modification_l1;
480   }
481
482   READ_UINT8 (nr, *ref_pic_list_modification_flag, 1);
483   if (*ref_pic_list_modification_flag) {
484     while (1) {
485       READ_UE (nr, modification_of_pic_nums_idc);
486       if (modification_of_pic_nums_idc == 3)
487         break;
488       if (modification_of_pic_nums_idc == 0 ||
489           modification_of_pic_nums_idc == 1) {
490         READ_UE_ALLOWED (nr, entries[i].value.abs_diff_pic_num_minus1, 0,
491             slice->max_pic_num - 1);
492       } else if (modification_of_pic_nums_idc == 2) {
493         READ_UE (nr, entries[i].value.long_term_pic_num);
494       }
495       entries[i++].modification_of_pic_nums_idc = modification_of_pic_nums_idc;
496     }
497   }
498   *n_ref_pic_list_modification = i;
499   return TRUE;
500
501 error:
502   GST_WARNING ("error parsing \"Reference picture list %u modification\"",
503       list);
504   return FALSE;
505 }
506
507 static gboolean
508 slice_parse_ref_pic_list_modification (GstH264SliceHdr * slice, NalReader * nr)
509 {
510   if (!GST_H264_IS_I_SLICE (slice) && !GST_H264_IS_SI_SLICE (slice)) {
511     if (!slice_parse_ref_pic_list_modification_1 (slice, nr, 0))
512       return FALSE;
513   }
514
515   if (GST_H264_IS_B_SLICE (slice)) {
516     if (!slice_parse_ref_pic_list_modification_1 (slice, nr, 1))
517       return FALSE;
518   }
519   return TRUE;
520 }
521
522 static gboolean
523 gst_h264_slice_parse_dec_ref_pic_marking (GstH264SliceHdr * slice,
524     GstH264NalUnit * nalu, NalReader * nr)
525 {
526   GstH264DecRefPicMarking *dec_ref_pic_m;
527
528   GST_DEBUG ("parsing \"Decoded reference picture marking\"");
529
530   dec_ref_pic_m = &slice->dec_ref_pic_marking;
531
532   if (nalu->idr_pic_flag) {
533     READ_UINT8 (nr, dec_ref_pic_m->no_output_of_prior_pics_flag, 1);
534     READ_UINT8 (nr, dec_ref_pic_m->long_term_reference_flag, 1);
535   } else {
536     READ_UINT8 (nr, dec_ref_pic_m->adaptive_ref_pic_marking_mode_flag, 1);
537     if (dec_ref_pic_m->adaptive_ref_pic_marking_mode_flag) {
538       guint32 mem_mgmt_ctrl_op;
539       GstH264RefPicMarking *refpicmarking;
540
541       dec_ref_pic_m->n_ref_pic_marking = 0;
542       while (1) {
543         refpicmarking =
544             &dec_ref_pic_m->ref_pic_marking[dec_ref_pic_m->n_ref_pic_marking];
545
546         READ_UE (nr, mem_mgmt_ctrl_op);
547         if (mem_mgmt_ctrl_op == 0)
548           break;
549
550         refpicmarking->memory_management_control_operation = mem_mgmt_ctrl_op;
551
552         if (mem_mgmt_ctrl_op == 1 || mem_mgmt_ctrl_op == 3)
553           READ_UE (nr, refpicmarking->difference_of_pic_nums_minus1);
554
555         if (mem_mgmt_ctrl_op == 2)
556           READ_UE (nr, refpicmarking->long_term_pic_num);
557
558         if (mem_mgmt_ctrl_op == 3 || mem_mgmt_ctrl_op == 6)
559           READ_UE (nr, refpicmarking->long_term_frame_idx);
560
561         if (mem_mgmt_ctrl_op == 4)
562           READ_UE (nr, refpicmarking->max_long_term_frame_idx_plus1);
563
564         dec_ref_pic_m->n_ref_pic_marking++;
565       }
566     }
567   }
568
569   return TRUE;
570
571 error:
572   GST_WARNING ("error parsing \"Decoded reference picture marking\"");
573   return FALSE;
574 }
575
576 static gboolean
577 gst_h264_slice_parse_pred_weight_table (GstH264SliceHdr * slice,
578     NalReader * nr, guint8 chroma_array_type)
579 {
580   GstH264PredWeightTable *p;
581   gint16 default_luma_weight, default_chroma_weight;
582   gint i;
583
584   GST_DEBUG ("parsing \"Prediction weight table\"");
585
586   p = &slice->pred_weight_table;
587
588   READ_UE_ALLOWED (nr, p->luma_log2_weight_denom, 0, 7);
589   /* set default values */
590   default_luma_weight = 1 << p->luma_log2_weight_denom;
591   for (i = 0; i < G_N_ELEMENTS (p->luma_weight_l0); i++)
592     p->luma_weight_l0[i] = default_luma_weight;
593   memset (p->luma_offset_l0, 0, sizeof (p->luma_offset_l0));
594   if (GST_H264_IS_B_SLICE (slice)) {
595     for (i = 0; i < G_N_ELEMENTS (p->luma_weight_l1); i++)
596       p->luma_weight_l1[i] = default_luma_weight;
597     memset (p->luma_offset_l1, 0, sizeof (p->luma_offset_l1));
598   }
599
600   if (chroma_array_type != 0) {
601     READ_UE_ALLOWED (nr, p->chroma_log2_weight_denom, 0, 7);
602     /* set default values */
603     default_chroma_weight = 1 << p->chroma_log2_weight_denom;
604     for (i = 0; i < G_N_ELEMENTS (p->chroma_weight_l0); i++) {
605       p->chroma_weight_l0[i][0] = default_chroma_weight;
606       p->chroma_weight_l0[i][1] = default_chroma_weight;
607     }
608     memset (p->chroma_offset_l0, 0, sizeof (p->chroma_offset_l0));
609     if (GST_H264_IS_B_SLICE (slice)) {
610       for (i = 0; i < G_N_ELEMENTS (p->chroma_weight_l1); i++) {
611         p->chroma_weight_l1[i][0] = default_chroma_weight;
612         p->chroma_weight_l1[i][1] = default_chroma_weight;
613       }
614       memset (p->chroma_offset_l1, 0, sizeof (p->chroma_offset_l1));
615     }
616   }
617
618   for (i = 0; i <= slice->num_ref_idx_l0_active_minus1; i++) {
619     guint8 luma_weight_l0_flag;
620
621     READ_UINT8 (nr, luma_weight_l0_flag, 1);
622     if (luma_weight_l0_flag) {
623       READ_SE_ALLOWED (nr, p->luma_weight_l0[i], -128, 127);
624       READ_SE_ALLOWED (nr, p->luma_offset_l0[i], -128, 127);
625     }
626     if (chroma_array_type != 0) {
627       guint8 chroma_weight_l0_flag;
628       gint j;
629
630       READ_UINT8 (nr, chroma_weight_l0_flag, 1);
631       if (chroma_weight_l0_flag) {
632         for (j = 0; j < 2; j++) {
633           READ_SE_ALLOWED (nr, p->chroma_weight_l0[i][j], -128, 127);
634           READ_SE_ALLOWED (nr, p->chroma_offset_l0[i][j], -128, 127);
635         }
636       }
637     }
638   }
639
640   if (GST_H264_IS_B_SLICE (slice)) {
641     for (i = 0; i <= slice->num_ref_idx_l1_active_minus1; i++) {
642       guint8 luma_weight_l1_flag;
643
644       READ_UINT8 (nr, luma_weight_l1_flag, 1);
645       if (luma_weight_l1_flag) {
646         READ_SE_ALLOWED (nr, p->luma_weight_l1[i], -128, 127);
647         READ_SE_ALLOWED (nr, p->luma_offset_l1[i], -128, 127);
648       }
649       if (chroma_array_type != 0) {
650         guint8 chroma_weight_l1_flag;
651         gint j;
652
653         READ_UINT8 (nr, chroma_weight_l1_flag, 1);
654         if (chroma_weight_l1_flag) {
655           for (j = 0; j < 2; j++) {
656             READ_SE_ALLOWED (nr, p->chroma_weight_l1[i][j], -128, 127);
657             READ_SE_ALLOWED (nr, p->chroma_offset_l1[i][j], -128, 127);
658           }
659         }
660       }
661     }
662   }
663
664   return TRUE;
665
666 error:
667   GST_WARNING ("error parsing \"Prediction weight table\"");
668   return FALSE;
669 }
670
671 static GstH264ParserResult
672 gst_h264_parser_parse_buffering_period (GstH264NalParser * nalparser,
673     GstH264BufferingPeriod * per, NalReader * nr)
674 {
675   GstH264SPS *sps;
676   guint8 sps_id;
677
678   GST_DEBUG ("parsing \"Buffering period\"");
679
680   READ_UE_ALLOWED (nr, sps_id, 0, GST_H264_MAX_SPS_COUNT - 1);
681   sps = gst_h264_parser_get_sps (nalparser, sps_id);
682   if (!sps) {
683     GST_WARNING ("couldn't find associated sequence parameter set with id: %d",
684         sps_id);
685     return GST_H264_PARSER_BROKEN_LINK;
686   }
687   per->sps = sps;
688
689   if (sps->vui_parameters_present_flag) {
690     GstH264VUIParams *vui = &sps->vui_parameters;
691
692     if (vui->nal_hrd_parameters_present_flag) {
693       GstH264HRDParams *hrd = &vui->nal_hrd_parameters;
694       const guint8 nbits = hrd->initial_cpb_removal_delay_length_minus1 + 1;
695       guint8 sched_sel_idx;
696
697       for (sched_sel_idx = 0; sched_sel_idx <= hrd->cpb_cnt_minus1;
698           sched_sel_idx++) {
699         READ_UINT8 (nr, per->nal_initial_cpb_removal_delay[sched_sel_idx],
700             nbits);
701         READ_UINT8 (nr,
702             per->nal_initial_cpb_removal_delay_offset[sched_sel_idx], nbits);
703       }
704     }
705
706     if (vui->vcl_hrd_parameters_present_flag) {
707       GstH264HRDParams *hrd = &vui->vcl_hrd_parameters;
708       const guint8 nbits = hrd->initial_cpb_removal_delay_length_minus1 + 1;
709       guint8 sched_sel_idx;
710
711       for (sched_sel_idx = 0; sched_sel_idx <= hrd->cpb_cnt_minus1;
712           sched_sel_idx++) {
713         READ_UINT8 (nr, per->vcl_initial_cpb_removal_delay[sched_sel_idx],
714             nbits);
715         READ_UINT8 (nr,
716             per->vcl_initial_cpb_removal_delay_offset[sched_sel_idx], nbits);
717       }
718     }
719   }
720
721   return GST_H264_PARSER_OK;
722
723 error:
724   GST_WARNING ("error parsing \"Buffering period\"");
725   return GST_H264_PARSER_ERROR;
726 }
727
728 static gboolean
729 gst_h264_parse_clock_timestamp (GstH264ClockTimestamp * tim,
730     GstH264VUIParams * vui, NalReader * nr)
731 {
732   guint8 full_timestamp_flag;
733   guint8 time_offset_length;
734
735   GST_DEBUG ("parsing \"Clock timestamp\"");
736
737   /* defalt values */
738   tim->time_offset = 0;
739
740   READ_UINT8 (nr, tim->ct_type, 2);
741   READ_UINT8 (nr, tim->nuit_field_based_flag, 1);
742   READ_UINT8 (nr, tim->counting_type, 5);
743   READ_UINT8 (nr, full_timestamp_flag, 1);
744   READ_UINT8 (nr, tim->discontinuity_flag, 1);
745   READ_UINT8 (nr, tim->cnt_dropped_flag, 1);
746   READ_UINT8 (nr, tim->n_frames, 8);
747
748   if (full_timestamp_flag) {
749     tim->seconds_flag = TRUE;
750     READ_UINT8 (nr, tim->seconds_value, 6);
751
752     tim->minutes_flag = TRUE;
753     READ_UINT8 (nr, tim->minutes_value, 6);
754
755     tim->hours_flag = TRUE;
756     READ_UINT8 (nr, tim->hours_value, 5);
757   } else {
758     READ_UINT8 (nr, tim->seconds_flag, 1);
759     if (tim->seconds_flag) {
760       READ_UINT8 (nr, tim->seconds_value, 6);
761       READ_UINT8 (nr, tim->minutes_flag, 1);
762       if (tim->minutes_flag) {
763         READ_UINT8 (nr, tim->minutes_value, 6);
764         READ_UINT8 (nr, tim->hours_flag, 1);
765         if (tim->hours_flag)
766           READ_UINT8 (nr, tim->hours_value, 5);
767       }
768     }
769   }
770
771   time_offset_length = 0;
772   if (vui->nal_hrd_parameters_present_flag)
773     time_offset_length = vui->nal_hrd_parameters.time_offset_length;
774   else if (vui->vcl_hrd_parameters_present_flag)
775     time_offset_length = vui->vcl_hrd_parameters.time_offset_length;
776
777   if (time_offset_length > 0)
778     READ_UINT32 (nr, tim->time_offset, time_offset_length);
779
780   return TRUE;
781
782 error:
783   GST_WARNING ("error parsing \"Clock timestamp\"");
784   return FALSE;
785 }
786
787 static GstH264ParserResult
788 gst_h264_parser_parse_pic_timing (GstH264NalParser * nalparser,
789     GstH264PicTiming * tim, NalReader * nr)
790 {
791   GST_DEBUG ("parsing \"Picture timing\"");
792   if (!nalparser->last_sps || !nalparser->last_sps->valid) {
793     GST_WARNING ("didn't get the associated sequence paramater set for the "
794         "current access unit");
795     goto error;
796   }
797
798   /* default values */
799   memset (tim->clock_timestamp_flag, 0, 3);
800
801   if (nalparser->last_sps->vui_parameters_present_flag) {
802     GstH264VUIParams *vui = &nalparser->last_sps->vui_parameters;
803
804     if (vui->nal_hrd_parameters_present_flag) {
805       READ_UINT32 (nr, tim->cpb_removal_delay,
806           vui->nal_hrd_parameters.cpb_removal_delay_length_minus1 + 1);
807       READ_UINT32 (nr, tim->dpb_output_delay,
808           vui->nal_hrd_parameters.dpb_output_delay_length_minus1 + 1);
809     } else if (vui->vcl_hrd_parameters_present_flag) {
810       READ_UINT32 (nr, tim->cpb_removal_delay,
811           vui->vcl_hrd_parameters.cpb_removal_delay_length_minus1 + 1);
812       READ_UINT32 (nr, tim->dpb_output_delay,
813           vui->vcl_hrd_parameters.dpb_output_delay_length_minus1 + 1);
814     }
815
816     if (vui->pic_struct_present_flag) {
817       const guint8 num_clock_ts_table[9] = {
818         1, 1, 1, 2, 2, 3, 3, 2, 3
819       };
820       guint8 num_clock_num_ts;
821       guint i;
822
823       tim->pic_struct_present_flag = TRUE;
824       READ_UINT8 (nr, tim->pic_struct, 4);
825       CHECK_ALLOWED ((gint8) tim->pic_struct, 0, 8);
826
827       num_clock_num_ts = num_clock_ts_table[tim->pic_struct];
828       for (i = 0; i < num_clock_num_ts; i++) {
829         READ_UINT8 (nr, tim->clock_timestamp_flag[i], 1);
830         if (tim->clock_timestamp_flag[i]) {
831           if (!gst_h264_parse_clock_timestamp (&tim->clock_timestamp[i], vui,
832                   nr))
833             goto error;
834         }
835       }
836     }
837   }
838
839   return GST_H264_PARSER_OK;
840
841 error:
842   GST_WARNING ("error parsing \"Picture timing\"");
843   return GST_H264_PARSER_ERROR;
844 }
845
846 static GstH264ParserResult
847 gst_h264_parser_parse_sei_message (GstH264NalParser * nalparser,
848     NalReader * nr, GstH264SEIMessage * sei)
849 {
850   guint32 payloadSize;
851   guint8 payload_type_byte, payload_size_byte;
852   guint remaining, payload_size;
853   GstH264ParserResult res;
854
855   GST_DEBUG ("parsing \"Sei message\"");
856
857   sei->payloadType = 0;
858   do {
859     READ_UINT8 (nr, payload_type_byte, 8);
860     sei->payloadType += payload_type_byte;
861   } while (payload_type_byte == 0xff);
862
863   payloadSize = 0;
864   do {
865     READ_UINT8 (nr, payload_size_byte, 8);
866     payloadSize += payload_size_byte;
867   }
868   while (payload_size_byte == 0xff);
869
870   remaining = nal_reader_get_remaining (nr);
871   payload_size = payloadSize * 8 < remaining ? payloadSize * 8 : remaining;
872
873   GST_DEBUG ("SEI message received: payloadType  %u, payloadSize = %u bits",
874       sei->payloadType, payload_size);
875
876   switch (sei->payloadType) {
877     case GST_H264_SEI_BUF_PERIOD:
878       /* size not set; might depend on emulation_prevention_three_byte */
879       res = gst_h264_parser_parse_buffering_period (nalparser,
880           &sei->payload.buffering_period, nr);
881       break;
882     case GST_H264_SEI_PIC_TIMING:
883       /* size not set; might depend on emulation_prevention_three_byte */
884       res = gst_h264_parser_parse_pic_timing (nalparser,
885           &sei->payload.pic_timing, nr);
886       break;
887     default:{
888       /* Just consume payloadSize bytes, which does not account for
889          emulation prevention bytes */
890       guint nbits = payload_size % 8;
891       while (payload_size > 0) {
892         nal_reader_skip (nr, nbits);
893         payload_size -= nbits;
894         nbits = 8;
895       }
896       res = GST_H264_PARSER_OK;
897       break;
898     }
899   }
900
901   /* When SEI message doesn't end at byte boundary,
902    * check remaining bits fit the specification.
903    */
904   if (!nal_reader_is_byte_aligned (nr)) {
905     guint8 bit_equal_to_one;
906     READ_UINT8 (nr, bit_equal_to_one, 1);
907     if (!bit_equal_to_one)
908       GST_WARNING ("Bit non equal to one.");
909
910     while (!nal_reader_is_byte_aligned (nr)) {
911       guint8 bit_equal_to_zero;
912       READ_UINT8 (nr, bit_equal_to_zero, 1);
913       if (bit_equal_to_zero)
914         GST_WARNING ("Bit non equal to zero.");
915     }
916   }
917
918   return res;
919
920 error:
921   GST_WARNING ("error parsing \"Sei message\"");
922   return GST_H264_PARSER_ERROR;
923 }
924
925 /******** API *************/
926
927 /**
928  * gst_h264_nal_parser_new:
929  *
930  * Creates a new #GstH264NalParser. It should be freed with
931  * gst_h264_nal_parser_free after use.
932  *
933  * Returns: a new #GstH264NalParser
934  */
935 GstH264NalParser *
936 gst_h264_nal_parser_new (void)
937 {
938   GstH264NalParser *nalparser;
939
940   nalparser = g_slice_new0 (GstH264NalParser);
941   INITIALIZE_DEBUG_CATEGORY;
942
943   return nalparser;
944 }
945
946 /**
947  * gst_h264_nal_parser_free:
948  * @nalparser: the #GstH264NalParser to free
949  *
950  * Frees @nalparser and sets it to %NULL
951  */
952 void
953 gst_h264_nal_parser_free (GstH264NalParser * nalparser)
954 {
955   g_slice_free (GstH264NalParser, nalparser);
956
957   nalparser = NULL;
958 }
959
960 /**
961  * gst_h264_parser_identify_nalu_unchecked:
962  * @nalparser: a #GstH264NalParser
963  * @data: The data to parse
964  * @offset: the offset from which to parse @data
965  * @size: the size of @data
966  * @nalu: The #GstH264NalUnit where to store parsed nal headers
967  *
968  * Parses @data and fills @nalu from the next nalu data from @data.
969  *
970  * This differs from @gst_h264_parser_identify_nalu in that it doesn't
971  * check whether the packet is complete or not.
972  *
973  * Note: Only use this function if you already know the provided @data
974  * is a complete NALU, else use @gst_h264_parser_identify_nalu.
975  *
976  * Returns: a #GstH264ParserResult
977  */
978 GstH264ParserResult
979 gst_h264_parser_identify_nalu_unchecked (GstH264NalParser * nalparser,
980     const guint8 * data, guint offset, gsize size, GstH264NalUnit * nalu)
981 {
982   gint off1;
983
984   if (size < offset + 4) {
985     GST_DEBUG ("Can't parse, buffer has too small size %" G_GSIZE_FORMAT
986         ", offset %u", size, offset);
987     return GST_H264_PARSER_ERROR;
988   }
989
990   off1 = scan_for_start_codes (data + offset, size - offset);
991
992   if (off1 < 0) {
993     GST_DEBUG ("No start code prefix in this buffer");
994     return GST_H264_PARSER_NO_NAL;
995   }
996
997   if (offset + off1 == size - 1) {
998     GST_DEBUG ("Missing data to identify nal unit");
999
1000     return GST_H264_PARSER_ERROR;
1001   }
1002
1003   nalu->sc_offset = offset + off1;
1004
1005
1006   nalu->offset = offset + off1 + 3;
1007   nalu->data = (guint8 *) data;
1008   nalu->size = size - nalu->offset;
1009
1010   if (!gst_h264_parse_nalu_header (nalu)) {
1011     GST_WARNING ("error parsing \"NAL unit header\"");
1012     nalu->size = 0;
1013     return GST_H264_PARSER_BROKEN_DATA;
1014   }
1015
1016   nalu->valid = TRUE;
1017
1018   /* sc might have 2 or 3 0-bytes */
1019   if (nalu->sc_offset > 0 && data[nalu->sc_offset - 1] == 00
1020       && (nalu->type == GST_H264_NAL_SPS || nalu->type == GST_H264_NAL_PPS
1021           || nalu->type == GST_H264_NAL_AU_DELIMITER))
1022     nalu->sc_offset--;
1023
1024   if (nalu->type == GST_H264_NAL_SEQ_END ||
1025       nalu->type == GST_H264_NAL_STREAM_END) {
1026     GST_DEBUG ("end-of-seq or end-of-stream nal found");
1027     nalu->size = 0;
1028     return GST_H264_PARSER_OK;
1029   }
1030
1031   return GST_H264_PARSER_OK;
1032 }
1033
1034 /**
1035  * gst_h264_parser_identify_nalu:
1036  * @nalparser: a #GstH264NalParser
1037  * @data: The data to parse
1038  * @offset: the offset from which to parse @data
1039  * @size: the size of @data
1040  * @nalu: The #GstH264NalUnit where to store parsed nal headers
1041  *
1042  * Parses @data and fills @nalu from the next nalu data from @data
1043  *
1044  * Returns: a #GstH264ParserResult
1045  */
1046 GstH264ParserResult
1047 gst_h264_parser_identify_nalu (GstH264NalParser * nalparser,
1048     const guint8 * data, guint offset, gsize size, GstH264NalUnit * nalu)
1049 {
1050   GstH264ParserResult res;
1051   gint off2;
1052
1053   res =
1054       gst_h264_parser_identify_nalu_unchecked (nalparser, data, offset, size,
1055       nalu);
1056
1057   if (res != GST_H264_PARSER_OK || nalu->size == 0)
1058     goto beach;
1059
1060   off2 = scan_for_start_codes (data + nalu->offset, size - nalu->offset);
1061   if (off2 < 0) {
1062     GST_DEBUG ("Nal start %d, No end found", nalu->offset);
1063
1064     return GST_H264_PARSER_NO_NAL_END;
1065   }
1066
1067   /* Mini performance improvement:
1068    * We could have a way to store how many 0s were skipped to avoid
1069    * parsing them again on the next NAL */
1070   while (off2 > 0 && data[nalu->offset + off2 - 1] == 00)
1071     off2--;
1072
1073   nalu->size = off2;
1074   if (nalu->size < 2)
1075     return GST_H264_PARSER_BROKEN_DATA;
1076
1077   GST_DEBUG ("Complete nal found. Off: %d, Size: %d", nalu->offset, nalu->size);
1078
1079 beach:
1080   return res;
1081 }
1082
1083
1084 /**
1085  * gst_h264_parser_identify_nalu_avc:
1086  * @nalparser: a #GstH264NalParser
1087  * @data: The data to parse, must be the beging of the Nal unit
1088  * @offset: the offset from which to parse @data
1089  * @size: the size of @data
1090  * @nal_length_size: the size in bytes of the AVC nal length prefix.
1091  * @nalu: The #GstH264NalUnit where to store parsed nal headers
1092  *
1093  * Parses @data and sets @nalu.
1094  *
1095  * Returns: a #GstH264ParserResult
1096  */
1097 GstH264ParserResult
1098 gst_h264_parser_identify_nalu_avc (GstH264NalParser * nalparser,
1099     const guint8 * data, guint offset, gsize size, guint8 nal_length_size,
1100     GstH264NalUnit * nalu)
1101 {
1102   GstBitReader br;
1103
1104   if (size < offset + nal_length_size) {
1105     GST_DEBUG ("Can't parse, buffer has too small size %" G_GSIZE_FORMAT
1106         ", offset %u", size, offset);
1107     return GST_H264_PARSER_ERROR;
1108   }
1109
1110   size = size - offset;
1111   gst_bit_reader_init (&br, data + offset, size);
1112
1113   nalu->size = gst_bit_reader_get_bits_uint32_unchecked (&br,
1114       nal_length_size * 8);
1115   nalu->sc_offset = offset;
1116   nalu->offset = offset + nal_length_size;
1117
1118   if (size < nalu->size + nal_length_size) {
1119     nalu->size = 0;
1120
1121     return GST_H264_PARSER_NO_NAL_END;
1122   }
1123
1124   nalu->data = (guint8 *) data;
1125
1126   if (!gst_h264_parse_nalu_header (nalu)) {
1127     GST_WARNING ("error parsing \"NAL unit header\"");
1128     nalu->size = 0;
1129     return GST_H264_PARSER_BROKEN_DATA;
1130   }
1131
1132   nalu->valid = TRUE;
1133
1134   return GST_H264_PARSER_OK;
1135 }
1136
1137 /**
1138  * gst_h264_parser_parse_nal:
1139  * @nalparser: a #GstH264NalParser
1140  * @nalu: The #GstH264NalUnit to parse
1141  *
1142  * This function should be called in the case one doesn't need to
1143  * parse a specific structure. It is necessary to do so to make
1144  * sure @nalparser is up to date.
1145  *
1146  * Returns: a #GstH264ParserResult
1147  */
1148 GstH264ParserResult
1149 gst_h264_parser_parse_nal (GstH264NalParser * nalparser, GstH264NalUnit * nalu)
1150 {
1151   GstH264SPS sps;
1152   GstH264PPS pps;
1153
1154   switch (nalu->type) {
1155     case GST_H264_NAL_SPS:
1156       return gst_h264_parser_parse_sps (nalparser, nalu, &sps, FALSE);
1157       break;
1158     case GST_H264_NAL_PPS:
1159       return gst_h264_parser_parse_pps (nalparser, nalu, &pps);
1160   }
1161
1162   return GST_H264_PARSER_OK;
1163 }
1164
1165 /**
1166  * gst_h264_parser_parse_sps:
1167  * @nalparser: a #GstH264NalParser
1168  * @nalu: The #GST_H264_NAL_SPS #GstH264NalUnit to parse
1169  * @sps: The #GstH264SPS to fill.
1170  * @parse_vui_params: Whether to parse the vui_params or not
1171  *
1172  * Parses @data, and fills the @sps structure.
1173  *
1174  * Returns: a #GstH264ParserResult
1175  */
1176 GstH264ParserResult
1177 gst_h264_parser_parse_sps (GstH264NalParser * nalparser, GstH264NalUnit * nalu,
1178     GstH264SPS * sps, gboolean parse_vui_params)
1179 {
1180   GstH264ParserResult res = gst_h264_parse_sps (nalu, sps, parse_vui_params);
1181
1182   if (res == GST_H264_PARSER_OK) {
1183     GST_DEBUG ("adding sequence parameter set with id: %d to array", sps->id);
1184
1185     nalparser->sps[sps->id] = *sps;
1186     nalparser->last_sps = &nalparser->sps[sps->id];
1187   }
1188
1189
1190
1191   return res;
1192 }
1193
1194 /* Parse seq_parameter_set_data() */
1195 static gboolean
1196 gst_h264_parse_sps_data (NalReader * nr, GstH264SPS * sps,
1197     gboolean parse_vui_params)
1198 {
1199   gint width, height;
1200   guint subwc[] = { 1, 2, 2, 1 };
1201   guint subhc[] = { 1, 2, 1, 1 };
1202   GstH264VUIParams *vui = NULL;
1203
1204   /* set default values for fields that might not be present in the bitstream
1205      and have valid defaults */
1206   sps->chroma_format_idc = 1;
1207   sps->separate_colour_plane_flag = 0;
1208   sps->bit_depth_luma_minus8 = 0;
1209   sps->bit_depth_chroma_minus8 = 0;
1210   memset (sps->scaling_lists_4x4, 16, 96);
1211   memset (sps->scaling_lists_8x8, 16, 384);
1212   memset (&sps->vui_parameters, 0, sizeof (sps->vui_parameters));
1213   sps->mb_adaptive_frame_field_flag = 0;
1214   sps->frame_crop_left_offset = 0;
1215   sps->frame_crop_right_offset = 0;
1216   sps->frame_crop_top_offset = 0;
1217   sps->frame_crop_bottom_offset = 0;
1218   sps->delta_pic_order_always_zero_flag = 0;
1219
1220   READ_UINT8 (nr, sps->profile_idc, 8);
1221   READ_UINT8 (nr, sps->constraint_set0_flag, 1);
1222   READ_UINT8 (nr, sps->constraint_set1_flag, 1);
1223   READ_UINT8 (nr, sps->constraint_set2_flag, 1);
1224   READ_UINT8 (nr, sps->constraint_set3_flag, 1);
1225
1226   /* skip reserved_zero_4bits */
1227   if (!nal_reader_skip (nr, 4))
1228     goto error;
1229
1230   READ_UINT8 (nr, sps->level_idc, 8);
1231
1232   READ_UE_ALLOWED (nr, sps->id, 0, GST_H264_MAX_SPS_COUNT - 1);
1233
1234   if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
1235       sps->profile_idc == 122 || sps->profile_idc == 244 ||
1236       sps->profile_idc == 44 || sps->profile_idc == 83 ||
1237       sps->profile_idc == 86) {
1238     READ_UE_ALLOWED (nr, sps->chroma_format_idc, 0, 3);
1239     if (sps->chroma_format_idc == 3)
1240       READ_UINT8 (nr, sps->separate_colour_plane_flag, 1);
1241
1242     READ_UE_ALLOWED (nr, sps->bit_depth_luma_minus8, 0, 6);
1243     READ_UE_ALLOWED (nr, sps->bit_depth_chroma_minus8, 0, 6);
1244     READ_UINT8 (nr, sps->qpprime_y_zero_transform_bypass_flag, 1);
1245
1246     READ_UINT8 (nr, sps->scaling_matrix_present_flag, 1);
1247     if (sps->scaling_matrix_present_flag) {
1248       guint8 n_lists;
1249
1250       n_lists = (sps->chroma_format_idc != 3) ? 8 : 12;
1251       if (!gst_h264_parser_parse_scaling_list (nr,
1252               sps->scaling_lists_4x4, sps->scaling_lists_8x8,
1253               default_4x4_inter, default_4x4_intra,
1254               default_8x8_inter, default_8x8_intra, n_lists))
1255         goto error;
1256     }
1257   }
1258
1259   READ_UE_ALLOWED (nr, sps->log2_max_frame_num_minus4, 0, 12);
1260
1261   sps->max_frame_num = 1 << (sps->log2_max_frame_num_minus4 + 4);
1262
1263   READ_UE_ALLOWED (nr, sps->pic_order_cnt_type, 0, 2);
1264   if (sps->pic_order_cnt_type == 0) {
1265     READ_UE_ALLOWED (nr, sps->log2_max_pic_order_cnt_lsb_minus4, 0, 12);
1266   } else if (sps->pic_order_cnt_type == 1) {
1267     guint i;
1268
1269     READ_UINT8 (nr, sps->delta_pic_order_always_zero_flag, 1);
1270     READ_SE (nr, sps->offset_for_non_ref_pic);
1271     READ_SE (nr, sps->offset_for_top_to_bottom_field);
1272     READ_UE_ALLOWED (nr, sps->num_ref_frames_in_pic_order_cnt_cycle, 0, 255);
1273
1274     for (i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; i++)
1275       READ_SE (nr, sps->offset_for_ref_frame[i]);
1276   }
1277
1278   READ_UE (nr, sps->num_ref_frames);
1279   READ_UINT8 (nr, sps->gaps_in_frame_num_value_allowed_flag, 1);
1280   READ_UE (nr, sps->pic_width_in_mbs_minus1);
1281   READ_UE (nr, sps->pic_height_in_map_units_minus1);
1282   READ_UINT8 (nr, sps->frame_mbs_only_flag, 1);
1283
1284   if (!sps->frame_mbs_only_flag)
1285     READ_UINT8 (nr, sps->mb_adaptive_frame_field_flag, 1);
1286
1287   READ_UINT8 (nr, sps->direct_8x8_inference_flag, 1);
1288   READ_UINT8 (nr, sps->frame_cropping_flag, 1);
1289   if (sps->frame_cropping_flag) {
1290     READ_UE (nr, sps->frame_crop_left_offset);
1291     READ_UE (nr, sps->frame_crop_right_offset);
1292     READ_UE (nr, sps->frame_crop_top_offset);
1293     READ_UE (nr, sps->frame_crop_bottom_offset);
1294   }
1295
1296   READ_UINT8 (nr, sps->vui_parameters_present_flag, 1);
1297   if (sps->vui_parameters_present_flag && parse_vui_params) {
1298     if (!gst_h264_parse_vui_parameters (sps, nr))
1299       goto error;
1300     vui = &sps->vui_parameters;
1301   }
1302
1303   /* calculate ChromaArrayType */
1304   if (sps->separate_colour_plane_flag)
1305     sps->chroma_array_type = 0;
1306   else
1307     sps->chroma_array_type = sps->chroma_format_idc;
1308
1309   /* Calculate  width and height */
1310   width = (sps->pic_width_in_mbs_minus1 + 1);
1311   width *= 16;
1312   height = (sps->pic_height_in_map_units_minus1 + 1);
1313   height *= 16 * (2 - sps->frame_mbs_only_flag);
1314   GST_LOG ("initial width=%d, height=%d", width, height);
1315   if (width < 0 || height < 0) {
1316     GST_WARNING ("invalid width/height in SPS");
1317     goto error;
1318   }
1319
1320   sps->width = width;
1321   sps->height = height;
1322
1323   if (sps->frame_cropping_flag) {
1324     const guint crop_unit_x = subwc[sps->chroma_format_idc];
1325     const guint crop_unit_y =
1326         subhc[sps->chroma_format_idc] * (2 - sps->frame_mbs_only_flag);
1327
1328     width -= (sps->frame_crop_left_offset + sps->frame_crop_right_offset)
1329         * crop_unit_x;
1330     height -= (sps->frame_crop_top_offset + sps->frame_crop_bottom_offset)
1331         * crop_unit_y;
1332
1333     sps->crop_rect_width = width;
1334     sps->crop_rect_height = height;
1335     sps->crop_rect_x = sps->frame_crop_left_offset * crop_unit_x;
1336     sps->crop_rect_y = sps->frame_crop_top_offset * crop_unit_y;
1337
1338     GST_LOG ("crop_rectangle x=%u y=%u width=%u, height=%u", sps->crop_rect_x,
1339         sps->crop_rect_y, width, height);
1340   }
1341   sps->fps_num = 0;
1342   sps->fps_den = 1;
1343
1344   if (vui && vui->timing_info_present_flag) {
1345     /* derive framerate */
1346     /* FIXME verify / also handle other cases */
1347     GST_LOG ("Framerate: %u %u %u %u", parse_vui_params,
1348         vui->fixed_frame_rate_flag, sps->frame_mbs_only_flag,
1349         vui->pic_struct_present_flag);
1350
1351     if (parse_vui_params && vui->fixed_frame_rate_flag &&
1352         sps->frame_mbs_only_flag && !vui->pic_struct_present_flag) {
1353       sps->fps_num = vui->time_scale;
1354       sps->fps_den = vui->num_units_in_tick;
1355       /* picture is a frame = 2 fields */
1356       sps->fps_den *= 2;
1357       GST_LOG ("framerate %d/%d", sps->fps_num, sps->fps_den);
1358     }
1359   } else {
1360     GST_LOG ("No VUI, unknown framerate");
1361   }
1362   return TRUE;
1363
1364 error:
1365   return FALSE;
1366 }
1367
1368 /**
1369  * gst_h264_parse_sps:
1370  * @nalu: The #GST_H264_NAL_SPS #GstH264NalUnit to parse
1371  * @sps: The #GstH264SPS to fill.
1372  * @parse_vui_params: Whether to parse the vui_params or not
1373  *
1374  * Parses @data, and fills the @sps structure.
1375  *
1376  * Returns: a #GstH264ParserResult
1377  */
1378 GstH264ParserResult
1379 gst_h264_parse_sps (GstH264NalUnit * nalu, GstH264SPS * sps,
1380     gboolean parse_vui_params)
1381 {
1382   NalReader nr;
1383
1384   INITIALIZE_DEBUG_CATEGORY;
1385   GST_DEBUG ("parsing SPS");
1386
1387   nal_reader_init (&nr, nalu->data + nalu->offset + 1, nalu->size - 1);
1388
1389   if (!gst_h264_parse_sps_data (&nr, sps, parse_vui_params))
1390     goto error;
1391
1392   sps->valid = TRUE;
1393
1394   return GST_H264_PARSER_OK;
1395
1396 error:
1397   GST_WARNING ("error parsing \"Sequence parameter set\"");
1398   sps->valid = FALSE;
1399   return GST_H264_PARSER_ERROR;
1400 }
1401
1402 /**
1403  * gst_h264_parse_pps:
1404  * @nalparser: a #GstH264NalParser
1405  * @nalu: The #GST_H264_NAL_PPS #GstH264NalUnit to parse
1406  * @pps: The #GstH264PPS to fill.
1407  *
1408  * Parses @data, and fills the @pps structure.
1409  *
1410  * Returns: a #GstH264ParserResult
1411  */
1412 GstH264ParserResult
1413 gst_h264_parse_pps (GstH264NalParser * nalparser, GstH264NalUnit * nalu,
1414     GstH264PPS * pps)
1415 {
1416   NalReader nr;
1417   GstH264SPS *sps;
1418   gint sps_id;
1419   guint8 pic_scaling_matrix_present_flag;
1420   gint qp_bd_offset;
1421
1422   INITIALIZE_DEBUG_CATEGORY;
1423   GST_DEBUG ("parsing PPS");
1424
1425   nal_reader_init (&nr, nalu->data + nalu->offset + 1, nalu->size - 1);
1426
1427   READ_UE_ALLOWED (&nr, pps->id, 0, GST_H264_MAX_PPS_COUNT - 1);
1428   READ_UE_ALLOWED (&nr, sps_id, 0, GST_H264_MAX_SPS_COUNT - 1);
1429
1430   sps = gst_h264_parser_get_sps (nalparser, sps_id);
1431   if (!sps) {
1432     GST_WARNING ("couldn't find associated sequence parameter set with id: %d",
1433         sps_id);
1434     return GST_H264_PARSER_BROKEN_LINK;
1435   }
1436   pps->sequence = sps;
1437   qp_bd_offset = 6 * (sps->bit_depth_luma_minus8 +
1438       sps->separate_colour_plane_flag);
1439
1440   /* set default values for fields that might not be present in the bitstream
1441      and have valid defaults */
1442   pps->slice_group_id = NULL;
1443   pps->transform_8x8_mode_flag = 0;
1444   memcpy (&pps->scaling_lists_4x4, &sps->scaling_lists_4x4, 96);
1445   memcpy (&pps->scaling_lists_8x8, &sps->scaling_lists_8x8, 384);
1446
1447   READ_UINT8 (&nr, pps->entropy_coding_mode_flag, 1);
1448   READ_UINT8 (&nr, pps->pic_order_present_flag, 1);
1449   READ_UE_ALLOWED (&nr, pps->num_slice_groups_minus1, 0, 7);
1450   if (pps->num_slice_groups_minus1 > 0) {
1451     READ_UE_ALLOWED (&nr, pps->slice_group_map_type, 0, 6);
1452
1453     if (pps->slice_group_map_type == 0) {
1454       gint i;
1455
1456       for (i = 0; i <= pps->num_slice_groups_minus1; i++)
1457         READ_UE (&nr, pps->run_length_minus1[i]);
1458     } else if (pps->slice_group_map_type == 2) {
1459       gint i;
1460
1461       for (i = 0; i <= pps->num_slice_groups_minus1; i++) {
1462         READ_UE (&nr, pps->top_left[i]);
1463         READ_UE (&nr, pps->bottom_right[i]);
1464       }
1465     } else if (pps->slice_group_map_type >= 3 && pps->slice_group_map_type <= 5) {
1466       READ_UINT8 (&nr, pps->slice_group_change_direction_flag, 1);
1467       READ_UE (&nr, pps->slice_group_change_rate_minus1);
1468     } else if (pps->slice_group_map_type == 6) {
1469       gint bits;
1470       gint i;
1471
1472       READ_UE (&nr, pps->pic_size_in_map_units_minus1);
1473       bits = g_bit_storage (pps->num_slice_groups_minus1);
1474
1475       pps->slice_group_id =
1476           g_new (guint8, pps->pic_size_in_map_units_minus1 + 1);
1477       for (i = 0; i <= pps->pic_size_in_map_units_minus1; i++)
1478         READ_UINT8 (&nr, pps->slice_group_id[i], bits);
1479     }
1480   }
1481
1482   READ_UE_ALLOWED (&nr, pps->num_ref_idx_l0_active_minus1, 0, 31);
1483   READ_UE_ALLOWED (&nr, pps->num_ref_idx_l1_active_minus1, 0, 31);
1484   READ_UINT8 (&nr, pps->weighted_pred_flag, 1);
1485   READ_UINT8 (&nr, pps->weighted_bipred_idc, 2);
1486   READ_SE_ALLOWED (&nr, pps->pic_init_qp_minus26, -(26 + qp_bd_offset), 25);
1487   READ_SE_ALLOWED (&nr, pps->pic_init_qs_minus26, -26, 25);
1488   READ_SE_ALLOWED (&nr, pps->chroma_qp_index_offset, -12, 12);
1489   pps->second_chroma_qp_index_offset = pps->chroma_qp_index_offset;
1490   READ_UINT8 (&nr, pps->deblocking_filter_control_present_flag, 1);
1491   READ_UINT8 (&nr, pps->constrained_intra_pred_flag, 1);
1492   READ_UINT8 (&nr, pps->redundant_pic_cnt_present_flag, 1);
1493
1494   if (!nal_reader_has_more_data (&nr))
1495     goto done;
1496
1497   READ_UINT8 (&nr, pps->transform_8x8_mode_flag, 1);
1498
1499   READ_UINT8 (&nr, pic_scaling_matrix_present_flag, 1);
1500   if (pic_scaling_matrix_present_flag) {
1501     guint8 n_lists;
1502
1503     n_lists = 6 + ((sps->chroma_format_idc != 3) ? 2 : 6) *
1504         pps->transform_8x8_mode_flag;
1505
1506     if (sps->scaling_matrix_present_flag) {
1507       if (!gst_h264_parser_parse_scaling_list (&nr,
1508               pps->scaling_lists_4x4, pps->scaling_lists_8x8,
1509               sps->scaling_lists_4x4[3], sps->scaling_lists_4x4[0],
1510               sps->scaling_lists_8x8[3], sps->scaling_lists_8x8[0], n_lists))
1511         goto error;
1512     } else {
1513       if (!gst_h264_parser_parse_scaling_list (&nr,
1514               pps->scaling_lists_4x4, pps->scaling_lists_8x8,
1515               default_4x4_inter, default_4x4_intra,
1516               default_8x8_inter, default_8x8_intra, n_lists))
1517         goto error;
1518     }
1519   }
1520
1521   READ_SE_ALLOWED (&nr, pps->second_chroma_qp_index_offset, -12, 12);
1522
1523 done:
1524   pps->valid = TRUE;
1525   return GST_H264_PARSER_OK;
1526
1527 error:
1528   GST_WARNING ("error parsing \"Picture parameter set\"");
1529   pps->valid = FALSE;
1530   return GST_H264_PARSER_ERROR;
1531 }
1532
1533 /**
1534  * gst_h264_parser_parse_pps:
1535  * @nalparser: a #GstH264NalParser
1536  * @nalu: The #GST_H264_NAL_PPS #GstH264NalUnit to parse
1537  * @pps: The #GstH264PPS to fill.
1538  *
1539  * Parses @data, and fills the @pps structure.
1540  *
1541  * Returns: a #GstH264ParserResult
1542  */
1543 GstH264ParserResult
1544 gst_h264_parser_parse_pps (GstH264NalParser * nalparser,
1545     GstH264NalUnit * nalu, GstH264PPS * pps)
1546 {
1547   GstH264ParserResult res = gst_h264_parse_pps (nalparser, nalu, pps);
1548
1549   if (res == GST_H264_PARSER_OK) {
1550     GST_DEBUG ("adding picture parameter set with id: %d to array", pps->id);
1551
1552     nalparser->pps[pps->id] = *pps;
1553     nalparser->last_pps = &nalparser->pps[pps->id];
1554   }
1555
1556   return res;
1557 }
1558
1559 /**
1560  * gst_h264_parser_parse_slice_hdr:
1561  * @nalparser: a #GstH264NalParser
1562  * @nalu: The #GST_H264_NAL_SLICE #GstH264NalUnit to parse
1563  * @slice: The #GstH264SliceHdr to fill.
1564  * @parse_pred_weight_table: Whether to parse the pred_weight_table or not
1565  * @parse_dec_ref_pic_marking: Whether to parse the dec_ref_pic_marking or not
1566  *
1567  * Parses @data, and fills the @slice structure.
1568  *
1569  * Returns: a #GstH264ParserResult
1570  */
1571 GstH264ParserResult
1572 gst_h264_parser_parse_slice_hdr (GstH264NalParser * nalparser,
1573     GstH264NalUnit * nalu, GstH264SliceHdr * slice,
1574     gboolean parse_pred_weight_table, gboolean parse_dec_ref_pic_marking)
1575 {
1576   NalReader nr;
1577   gint pps_id;
1578   GstH264PPS *pps;
1579   GstH264SPS *sps;
1580
1581   if (!nalu->size) {
1582     GST_DEBUG ("Invalid Nal Unit");
1583     return GST_H264_PARSER_ERROR;
1584   }
1585
1586
1587   nal_reader_init (&nr, nalu->data + nalu->offset + 1, nalu->size - 1);
1588
1589   READ_UE (&nr, slice->first_mb_in_slice);
1590   READ_UE (&nr, slice->type);
1591
1592   GST_DEBUG ("parsing \"Slice header\", slice type %u", slice->type);
1593
1594   READ_UE_ALLOWED (&nr, pps_id, 0, GST_H264_MAX_PPS_COUNT - 1);
1595   pps = gst_h264_parser_get_pps (nalparser, pps_id);
1596
1597   if (!pps) {
1598     GST_WARNING ("couldn't find associated picture parameter set with id: %d",
1599         pps_id);
1600
1601     return GST_H264_PARSER_BROKEN_LINK;
1602   }
1603
1604   slice->pps = pps;
1605   sps = pps->sequence;
1606   if (!sps) {
1607     GST_WARNING ("couldn't find associated sequence parameter set with id: %d",
1608         pps->id);
1609     return GST_H264_PARSER_BROKEN_LINK;
1610   }
1611
1612   /* set default values for fields that might not be present in the bitstream
1613      and have valid defaults */
1614   slice->field_pic_flag = 0;
1615   slice->bottom_field_flag = 0;
1616   slice->delta_pic_order_cnt_bottom = 0;
1617   slice->delta_pic_order_cnt[0] = 0;
1618   slice->delta_pic_order_cnt[1] = 0;
1619   slice->redundant_pic_cnt = 0;
1620   slice->num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_active_minus1;
1621   slice->num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_active_minus1;
1622   slice->disable_deblocking_filter_idc = 0;
1623   slice->slice_alpha_c0_offset_div2 = 0;
1624   slice->slice_beta_offset_div2 = 0;
1625
1626   if (sps->separate_colour_plane_flag)
1627     READ_UINT8 (&nr, slice->colour_plane_id, 2);
1628
1629   READ_UINT16 (&nr, slice->frame_num, sps->log2_max_frame_num_minus4 + 4);
1630
1631   if (!sps->frame_mbs_only_flag) {
1632     READ_UINT8 (&nr, slice->field_pic_flag, 1);
1633     if (slice->field_pic_flag)
1634       READ_UINT8 (&nr, slice->bottom_field_flag, 1);
1635   }
1636
1637   /* calculate MaxPicNum */
1638   if (slice->field_pic_flag)
1639     slice->max_pic_num = sps->max_frame_num;
1640   else
1641     slice->max_pic_num = 2 * sps->max_frame_num;
1642
1643   if (nalu->type == 5)
1644     READ_UE_ALLOWED (&nr, slice->idr_pic_id, 0, G_MAXUINT16);
1645
1646   if (sps->pic_order_cnt_type == 0) {
1647     READ_UINT16 (&nr, slice->pic_order_cnt_lsb,
1648         sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
1649
1650     if (pps->pic_order_present_flag && !slice->field_pic_flag)
1651       READ_SE (&nr, slice->delta_pic_order_cnt_bottom);
1652   }
1653
1654   if (sps->pic_order_cnt_type == 1 && !sps->delta_pic_order_always_zero_flag) {
1655     READ_SE (&nr, slice->delta_pic_order_cnt[0]);
1656     if (pps->pic_order_present_flag && !slice->field_pic_flag)
1657       READ_SE (&nr, slice->delta_pic_order_cnt[1]);
1658   }
1659
1660   if (pps->redundant_pic_cnt_present_flag)
1661     READ_UE_ALLOWED (&nr, slice->redundant_pic_cnt, 0, G_MAXINT8);
1662
1663   if (GST_H264_IS_B_SLICE (slice))
1664     READ_UINT8 (&nr, slice->direct_spatial_mv_pred_flag, 1);
1665
1666   if (GST_H264_IS_P_SLICE (slice) || GST_H264_IS_SP_SLICE (slice) ||
1667       GST_H264_IS_B_SLICE (slice)) {
1668     guint8 num_ref_idx_active_override_flag;
1669
1670     READ_UINT8 (&nr, num_ref_idx_active_override_flag, 1);
1671     if (num_ref_idx_active_override_flag) {
1672       READ_UE_ALLOWED (&nr, slice->num_ref_idx_l0_active_minus1, 0, 31);
1673
1674       if (GST_H264_IS_B_SLICE (slice))
1675         READ_UE_ALLOWED (&nr, slice->num_ref_idx_l1_active_minus1, 0, 31);
1676     }
1677   }
1678
1679   if (!slice_parse_ref_pic_list_modification (slice, &nr))
1680     goto error;
1681
1682   if ((pps->weighted_pred_flag && (GST_H264_IS_P_SLICE (slice)
1683               || GST_H264_IS_SP_SLICE (slice)))
1684       || (pps->weighted_bipred_idc == 1 && GST_H264_IS_B_SLICE (slice))) {
1685     if (!gst_h264_slice_parse_pred_weight_table (slice, &nr,
1686             sps->chroma_array_type))
1687       goto error;
1688   }
1689
1690   if (nalu->ref_idc != 0) {
1691     if (!gst_h264_slice_parse_dec_ref_pic_marking (slice, nalu, &nr))
1692       goto error;
1693   }
1694
1695   if (pps->entropy_coding_mode_flag && !GST_H264_IS_I_SLICE (slice) &&
1696       !GST_H264_IS_SI_SLICE (slice))
1697     READ_UE_ALLOWED (&nr, slice->cabac_init_idc, 0, 2);
1698
1699   READ_SE_ALLOWED (&nr, slice->slice_qp_delta, -87, 77);
1700
1701   if (GST_H264_IS_SP_SLICE (slice) || GST_H264_IS_SI_SLICE (slice)) {
1702     guint8 sp_for_switch_flag;
1703
1704     if (GST_H264_IS_SP_SLICE (slice))
1705       READ_UINT8 (&nr, sp_for_switch_flag, 1);
1706     READ_SE_ALLOWED (&nr, slice->slice_qs_delta, -51, 51);
1707   }
1708
1709   if (pps->deblocking_filter_control_present_flag) {
1710     READ_UE_ALLOWED (&nr, slice->disable_deblocking_filter_idc, 0, 2);
1711     if (slice->disable_deblocking_filter_idc != 1) {
1712       READ_SE_ALLOWED (&nr, slice->slice_alpha_c0_offset_div2, -6, 6);
1713       READ_SE_ALLOWED (&nr, slice->slice_beta_offset_div2, -6, 6);
1714     }
1715   }
1716
1717   if (pps->num_slice_groups_minus1 > 0 &&
1718       pps->slice_group_map_type >= 3 && pps->slice_group_map_type <= 5) {
1719     /* Ceil(Log2(PicSizeInMapUnits / SliceGroupChangeRate + 1))  [7-33] */
1720     guint32 PicWidthInMbs = sps->pic_width_in_mbs_minus1 + 1;
1721     guint32 PicHeightInMapUnits = sps->pic_height_in_map_units_minus1 + 1;
1722     guint32 PicSizeInMapUnits = PicWidthInMbs * PicHeightInMapUnits;
1723     guint32 SliceGroupChangeRate = pps->slice_group_change_rate_minus1 + 1;
1724     const guint n = ceil_log2 (PicSizeInMapUnits / SliceGroupChangeRate + 1);
1725     READ_UINT16 (&nr, slice->slice_group_change_cycle, n);
1726   }
1727
1728   slice->header_size = nal_reader_get_pos (&nr);
1729   slice->n_emulation_prevention_bytes = nal_reader_get_epb_count (&nr);
1730
1731   return GST_H264_PARSER_OK;
1732
1733 error:
1734   GST_WARNING ("error parsing \"Slice header\"");
1735   return GST_H264_PARSER_ERROR;
1736 }
1737
1738 /**
1739  * gst_h264_parser_parse_sei:
1740  * @nalparser: a #GstH264NalParser
1741  * @nalu: The #GST_H264_NAL_SEI #GstH264NalUnit to parse
1742  * @messages: The GArray of #GstH264SEIMessage to fill. The caller must free it when done.
1743  *
1744  * Parses @data, create and fills the @messages array.
1745  *
1746  * Returns: a #GstH264ParserResult
1747  */
1748 GstH264ParserResult
1749 gst_h264_parser_parse_sei (GstH264NalParser * nalparser, GstH264NalUnit * nalu,
1750     GArray ** messages)
1751 {
1752   NalReader nr;
1753   GstH264SEIMessage sei;
1754   GstH264ParserResult res;
1755
1756   GST_DEBUG ("parsing SEI nal");
1757   nal_reader_init (&nr, nalu->data + nalu->offset + 1, nalu->size - 1);
1758   *messages = g_array_new (FALSE, FALSE, sizeof (GstH264SEIMessage));
1759
1760   do {
1761     res = gst_h264_parser_parse_sei_message (nalparser, &nr, &sei);
1762     if (res == GST_H264_PARSER_OK)
1763       g_array_append_val (*messages, sei);
1764     else
1765       break;
1766   } while (nal_reader_has_more_data (&nr));
1767
1768   return res;
1769 }
1770
1771 /**
1772  * gst_h264_video_quant_matrix_8x8_get_zigzag_from_raster:
1773  * @out_quant: (out): The resulting quantization matrix
1774  * @quant: The source quantization matrix
1775  *
1776  * Converts quantization matrix @quant from raster scan order to
1777  * zigzag scan order and store the resulting factors into @out_quant.
1778  *
1779  * Note: it is an error to pass the same table in both @quant and
1780  * @out_quant arguments.
1781  *
1782  * Since: 1.4
1783  */
1784 void
1785 gst_h264_video_quant_matrix_8x8_get_zigzag_from_raster (guint8 out_quant[64],
1786     const guint8 quant[64])
1787 {
1788   guint i;
1789
1790   g_return_if_fail (out_quant != quant);
1791
1792   for (i = 0; i < 64; i++)
1793     out_quant[i] = quant[zigzag_8x8[i]];
1794 }
1795
1796 /**
1797  * gst_h264_quant_matrix_8x8_get_raster_from_zigzag:
1798  * @out_quant: (out): The resulting quantization matrix
1799  * @quant: The source quantization matrix
1800  *
1801  * Converts quantization matrix @quant from zigzag scan order to
1802  * raster scan order and store the resulting factors into @out_quant.
1803  *
1804  * Note: it is an error to pass the same table in both @quant and
1805  * @out_quant arguments.
1806  *
1807  * Since: 1.4
1808  */
1809 void
1810 gst_h264_video_quant_matrix_8x8_get_raster_from_zigzag (guint8 out_quant[64],
1811     const guint8 quant[64])
1812 {
1813   guint i;
1814
1815   g_return_if_fail (out_quant != quant);
1816
1817   for (i = 0; i < 64; i++)
1818     out_quant[zigzag_8x8[i]] = quant[i];
1819 }
1820
1821 /**
1822  * gst_h264_video_quant_matrix_4x4_get_zigzag_from_raster:
1823  * @out_quant: (out): The resulting quantization matrix
1824  * @quant: The source quantization matrix
1825  *
1826  * Converts quantization matrix @quant from raster scan order to
1827  * zigzag scan order and store the resulting factors into @out_quant.
1828  *
1829  * Note: it is an error to pass the same table in both @quant and
1830  * @out_quant arguments.
1831  *
1832  * Since: 1.4
1833  */
1834 void
1835 gst_h264_video_quant_matrix_4x4_get_zigzag_from_raster (guint8 out_quant[16],
1836     const guint8 quant[16])
1837 {
1838   guint i;
1839
1840   g_return_if_fail (out_quant != quant);
1841
1842   for (i = 0; i < 16; i++)
1843     out_quant[i] = quant[zigzag_4x4[i]];
1844 }
1845
1846 /**
1847  * gst_h264_quant_matrix_4x4_get_raster_from_zigzag:
1848  * @out_quant: (out): The resulting quantization matrix
1849  * @quant: The source quantization matrix
1850  *
1851  * Converts quantization matrix @quant from zigzag scan order to
1852  * raster scan order and store the resulting factors into @out_quant.
1853  *
1854  * Note: it is an error to pass the same table in both @quant and
1855  * @out_quant arguments.
1856  *
1857  * Since: 1.4
1858  */
1859 void
1860 gst_h264_video_quant_matrix_4x4_get_raster_from_zigzag (guint8 out_quant[16],
1861     const guint8 quant[16])
1862 {
1863   guint i;
1864
1865   g_return_if_fail (out_quant != quant);
1866
1867   for (i = 0; i < 16; i++)
1868     out_quant[zigzag_4x4[i]] = quant[i];
1869 }