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