Fix a few glitches in nal_parser. Still slicing needs to be fixed.

--HG--
rename : src/libxinevdec/nal_parser.c => src/libvdpau/nal_parser.c
rename : src/libxinevdec/nal_parser.h => src/libvdpau/nal_parser.h

2 files changed, 0 insertions, 867 deletions

diff --git a/src/libxinevdec/nal_parser.c b/src/libxinevdec/nal_parser.c
deleted file mode 100644
index 916595cad..000000000
--- a/src/libxinevdec/nal_parser.c
+++ /dev/null
@@ -1,652 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-#include "nal_parser.h"
-
-struct buf_reader {
-    uint8_t *buf;
-    uint8_t *cur_pos;
-    int len;
-    int cur_offset;
-};
-
-static inline uint32_t read_bits(struct buf_reader *buf, int len);
-uint32_t read_exp_golomb(struct buf_reader *buf);
-int32_t read_exp_golomb_s(struct buf_reader *buf);
-void skip_scaling_list(struct buf_reader *buf, int size);
-int parse_nal_header(struct buf_reader *buf, struct nal_unit *nal);
-uint8_t parse_sps(struct buf_reader *buf, struct seq_parameter_set_rbsp *sps);
-uint8_t parse_pps(struct buf_reader *buf, struct pic_parameter_set_rbsp *pps);
-uint8_t parse_slice_header(struct buf_reader *buf, struct nal_unit *nal);
-
-
-static void decode_nal(uint8_t **ret, int *len_ret, uint8_t *buf, int buf_len)
-{
-    uint8_t *end = &buf[buf_len];
-    uint8_t *pos = malloc(buf_len);
-
-    *ret = pos;
-    while(buf < end) {
-        if(buf < end - 3 && buf[0] == 0x00 && buf[1] == 0x00 &&
-           buf[2] == 0x03) {
-
-            *pos++ = 0x00;
-            *pos++ = 0x00;
-
-            buf += 3;
-            continue;
-        }
-        *pos++ = *buf++;
-    }
-
-    *len_ret = pos - *ret;
-}
-
-/*uint32_t read_bits(struct buf_reader *buf, int len)
-{
-    uint32_t bits = 0x00;
-    int i, j;
-    for(i=0, j=0; i<len; i++) {
-        while(buf->cur_offset >= 8) {
-            buf->cur_pos++;
-            buf->cur_offset -= 8;
-        }
-        uint8_t bit = (*buf->cur_pos >> (7 - buf->cur_offset)) & 0x01;
-        bits |= ((uint32_t)bit) << i;
-        buf->cur_offset++;
-    }
-printf("ret: 0x%08x\n", bits);
-    return bits;
-}*/
-
-static inline uint32_t read_bits (struct buf_reader *buf, int len)
-{
-    static uint32_t i_mask[33] =
-    {  0x00,
-       0x01,      0x03,      0x07,      0x0f,
-       0x1f,      0x3f,      0x7f,      0xff,
-       0x1ff,     0x3ff,     0x7ff,     0xfff,
-       0x1fff,    0x3fff,    0x7fff,    0xffff,
-       0x1ffff,   0x3ffff,   0x7ffff,   0xfffff,
-       0x1fffff,  0x3fffff,  0x7fffff,  0xffffff,
-       0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff,
-       0x1fffffff,0x3fffffff,0x7fffffff,0xffffffff};
-
-    int i_shr;
-    uint32_t bits = 0;
-
-    while(len > 0 && (buf->cur_pos - buf->buf) < buf->len) {
-        if((i_shr = buf->cur_offset-len) >= 0) {
-            bits |= (*buf->cur_pos >> i_shr)&i_mask[len];
-            buf->cur_offset -= len;
-            if(buf->cur_offset == 0) {
-                buf->cur_pos++;
-                buf->cur_offset = 8;
-            }
-            return bits;
-        } else {
-            bits |= (*buf->cur_pos & i_mask[buf->cur_offset]) << -i_shr;
-            len -= buf->cur_offset;
-            buf->cur_pos++;
-            buf->cur_offset = 8;
-        }
-    }
-    return bits;
-}
-
-/* determines if following bits are rtsb_trailing_bits */
-static inline uint8_t rbsp_trailing_bits(struct buf_reader *buf)
-{
-	// store the offset and pos in buffer
-	// to revert this afterwards.
-	int last_offset;
-	uint8_t *last_pos;
-
-	uint8_t rbsp_trailing_bits = 1;
-
-	offset = buf->cur_offset;
-	pos = buf->cur_pos;
-
-	if(read_bits(buf, 1) == 1)
-	{
-		while(buf->cur_offset != 8)
-			if(read_bits(buf, 1) == 1)
-				rbsp_trailing_bits = 0;
-	}
-
-	// revert buffer
-	buf->cur_offset = offset;
-	buf->cur_pos = pos;
-
-	return rbsp_trailing_bits;
-}
-
-uint32_t read_exp_golomb(struct buf_reader *buf)
-{
-    int leading_zero_bits = 0;
-
-    while(read_bits(buf, 1) == 0 && leading_zero_bits < 32)
-        leading_zero_bits++;
-
-    uint32_t code = (1<<leading_zero_bits) - 1 + read_bits(buf, leading_zero_bits);
-    return code;
-}
-
-int32_t read_exp_golomb_s(struct buf_reader *buf)
-{
-    uint32_t ue = read_exp_golomb(buf);
-    int32_t code = ue&0x01 ? (ue+1)/2 : -(ue/2);
-    return code;
-}
-
-int parse_nal_header(struct buf_reader *buf, struct nal_unit *nal)
-{
-    if(buf->len < 1)
-        return -1;
-    int ret = -1;
-
-    nal->nal_ref_idc = (buf->buf[0] >> 5) & 0x03;
-    nal->nal_unit_type = buf->buf[0] & 0x1f;
-
-    buf->cur_pos = buf->buf + 1;
-    //printf("NAL: %d\n", nal->nal_unit_type);
-
-    struct buf_reader ibuf;
-    ibuf.cur_offset = 8;
-
-    switch(nal->nal_unit_type) {
-        case NAL_SPS:
-            decode_nal(&ibuf.buf, &ibuf.len, buf->cur_pos, buf->len-1);
-            ibuf.cur_pos = ibuf.buf;
-            if(!nal->sps)
-                nal->sps = malloc(sizeof(struct seq_parameter_set_rbsp));
-            else
-                memset(nal->sps, 0x00, sizeof(struct seq_parameter_set_rbsp));
-
-            parse_sps(&ibuf, nal->sps);
-            free(ibuf.buf);
-            ret = NAL_SPS;
-            break;
-        case NAL_PPS:
-            if(!nal->pps)
-                nal->pps = malloc(sizeof(struct pic_parameter_set_rbsp));
-            else
-                memset(nal->pps, 0x00, sizeof(struct pic_parameter_set_rbsp));
-
-            parse_pps(buf, nal->pps);
-            ret = NAL_PPS;
-            break;
-        case NAL_SLICE:
-        case NAL_PART_A:
-        case NAL_PART_B:
-        case NAL_PART_C:
-        case NAL_SLICE_IDR:
-            if(nal->sps && nal->pps) {
-                if(!nal->slc)
-                    nal->slc = malloc(sizeof(struct slice_header));
-                else
-                    memset(nal->slc, 0x00, sizeof(struct slice_header));
-
-                parse_slice_header(buf, nal);
-                ret = nal->nal_unit_type;
-            }
-            break;
-        default:
-            ret = nal->nal_unit_type;
-            break;
-    }
-
-    return ret;
-}
-
-void skip_scaling_list(struct buf_reader *buf, int size)
-{
-    int i;
-    for(i = 0; i < size; i++) {
-        read_exp_golomb_s(buf);
-    }
-}
-
-void parse_scaling_list(struct buf_reader *buf, uint8_t *scaling_list, int length, int index)
-{
-	int last_scale = 8;
-	int next_scale = 8;
-	int32_t delta_scale;
-	uint8_t use_default_scaling_matrix_flag = 0;
-	int i;
-
-	for(i = 0; i < length; i++) {
-		if(next_scale != 0) {
-			delta_scale = read_exp_golomb_s(buf);
-			next_scale = (last_scale + delta_scale + 256) % 256;
-			if(i == 0 && next_scale == 0) {
-				use_default_scaling_matrix_flag = 1;
-				break;
-			}
-		}
-		scaling_list = (next_scale == 0) ? last_scale : next_scale;
-		last_scale = scaling_list->scaling_list[i];
-	}
-
-	if(use_default_scaling_matrix_flag) {
-		switch(index) {
-			case 0:
-			case 1:
-			case 2:
-				memcpy(scaling_list, length, default_4x4_intra);
-				break;
-			case 3:
-			case 4:
-			case 5:
-				memcpy(scaling_list, length, default_4x4_inter);
-				break;
-			case 6:
-				memcpy(scaling_list, length, default_8x8_intra);
-				break;
-			case 7:
-				memcpy(scaling_list, length, default_8x8_inter);
-				break;
-		}
-	}
-}
-
-uint8_t parse_sps(struct buf_reader *buf, struct seq_parameter_set_rbsp *sps)
-{
-    sps->profile_idc = buf->buf[0];
-    sps->constraint_setN_flag = (buf->buf[1] >> 4) & 0x0f;
-    sps->level_idc = buf->buf[2];
-
-    buf->cur_pos = buf->buf+3;
-    sps->seq_parameter_set_id = read_exp_golomb(buf);
-    if(sps->profile_idc == 100 || sps->profile_idc == 110 ||
-       sps->profile_idc == 122 || sps->profile_idc == 144) {
-        sps->chroma_format_idc = read_exp_golomb(buf);
-        if(sps->chroma_format_idc == 3) {
-            sps->residual_colour_transform_flag = read_bits(buf, 1);
-        }
-
-        sps->bit_depth_luma_minus8 = read_exp_golomb(buf);
-        sps->bit_depth_chroma_minus8 = read_exp_golomb(buf);
-        sps->qpprime_y_zero_transform_bypass_flag = read_bits(buf, 1);
-        sps->seq_scaling_matrix_present_flag = read_bits(buf, 1);
-        if(sps->seq_scaling_matrix_present_flag) {
-        	int i;
-			for(i = 0; i < 8; i++) {
-				sps->seq_scaling_list_present_flag[i] = read_bits(buf, 1);
-
-				if(sps->seq_scaling_list_present_flag[i]) {
-					if(i < 6)
-						parse_scaling_list(buf, sps->scaling_lists_4x4[i], 16, i);
-					else
-						parse_scaling_list(buf, sps->scaling_lists_8x8[i-6], 64, i);
-				}
-			}
-        }
-    }
-
-    sps->log2_max_frame_num_minus4 = read_exp_golomb(buf);
-
-    sps->pic_order_cnt_type = read_exp_golomb(buf);
-    if(!sps->pic_order_cnt_type)
-        sps->log2_max_pic_order_cnt_lsb_minus4 = read_exp_golomb(buf);
-    else {
-        sps->delta_pic_order_always_zero_flag = read_bits(buf, 1);
-        sps->offset_for_non_ref_pic = read_exp_golomb_s(buf);
-        sps->offset_for_top_to_bottom_field = read_exp_golomb_s(buf);
-        sps->num_ref_frames_in_pic_order_cnt_cycle = read_exp_golomb(buf);
-        int i;
-        for(i=0; i<sps->num_ref_frames_in_pic_order_cnt_cycle; i++) {
-            sps->offset_for_ref_frame[i] = read_exp_golomb_s(buf);
-        }
-    }
-    sps->num_ref_frames = read_exp_golomb(buf);
-    sps->gaps_in_frame_num_value_allowed_flag = read_bits(buf, 1);
-
-    /*sps->pic_width_in_mbs_minus1 = read_exp_golomb(buf);
-    sps->pic_height_in_map_units_minus1 = read_exp_golomb(buf);*/
-    sps->pic_width = 16 * (read_exp_golomb(buf) + 1);
-    sps->pic_height = 16 * (read_exp_golomb(buf) + 1);
-
-    sps->frame_mbs_only_flag = read_bits(buf, 1);
-
-    /* compute the height correctly even for interlaced material */
-    sps->pic_height = (2-sps->frame_mbs_only_flag) * sps->pic_height;
-    if(sps->pic_height == 1088)
-      sps->pic_height = 1080;
-    //printf("res: %dx%d\n", sps->pic_width, sps->pic_height);
-
-    if(!sps->frame_mbs_only_flag)
-        sps->mb_adaptive_frame_field_flag = read_bits(buf, 1);
-
-    sps->direct_8x8_inference_flag = read_bits(buf, 1);
-    sps->frame_cropping_flag = read_bits(buf, 1);
-    if(sps->frame_cropping_flag) {
-        sps->frame_crop_left_offset = read_exp_golomb(buf);
-        sps->frame_crop_right_offset = read_exp_golomb(buf);
-        sps->frame_crop_top_offset = read_exp_golomb(buf);
-        sps->frame_crop_bottom_offset = read_exp_golomb(buf);
-    }
-    sps->vui_parameters_present_flag = read_bits(buf, 1);
-    /*if(sps->vui_parameters_present_flag)
-        printf("ERROR: vui_parameters is not implemented\n");*/
-
-    return 0;
-}
-
-uint8_t parse_pps(struct buf_reader *buf, struct pic_parameter_set_rbsp *pps)
-{
-    pps->pic_parameter_set_id = read_exp_golomb(buf);
-    pps->seq_parameter_set_id = read_exp_golomb(buf);
-    pps->entropy_coding_mode_flag = read_bits(buf, 1);
-    pps->pic_order_present_flag = read_bits(buf, 1);
-
-    pps->num_slice_groups_minus1 = read_exp_golomp(buf);
-    if(pps->num_slice_groups_minus1 > 0) {
-    	pps->slice_group_map_type = read_exp_golomb(buf);
-    	if(pps->slice_group_map_type == 0) {
-    		int i_group;
-    		for(i_group = 0; i_group <= pps->num_slice_groups_minus1; i_group++) {
-    			if(i_group < 64)
-    				pps->run_length_minus1[i_group] = read_exp_golomb(buf);
-    			else { // FIXME: skips if more than 64 groups exist
-    				fprintf(stderr, "Error: Only 64 slice_groups are supported\n");
-    				read_exp_golomb(buf);
-    			}
-    		}
-    	} else if(pps->slice_group_map_type == 3 ||
-    			pps->slice_group_map_type == 4 ||
-    			pps->slice_group_map_type == 5) {
-    		pps->slice_group_change_direction_flag = read_bits(buf, 1);
-    		pps->slice_group_change_rate_minus1 = read_exp_golomb(buf);
-    	} else if(pps->slice_group_map_type == 6) {
-    		pps->pic_size_in_map_units_minus1 = read_exp_golomb(buf);
-    		int i_group;
-    		for(i_group = 0; i_group <= pps->num_slice_groups_minus1; i_group++) {
-    			pps->slice_group_id[i_group] =
-    				read_bits(buf, ceil(log2(pps->num_slice_groups_minus1 + 1)));
-    		}
-    	}
-    }
-
-    pps->num_ref_idx_l0_active_minus1 = read_exp_golomb(buf);
-    pps->num_ref_idx_l1_active_minus1 = read_exp_golomb(buf);
-    pps->weighted_pred_flag = read_bits(buf, 1);
-    pps->weighted_bipred_flag = read_bits(buf, 2);
-    pps->pic_init_qp_minus26 = read_exp_golomb_s(buf);
-    pps->pic_init_qs_minus26 = read_exp_golomb_s(buf);
-    pps->chroma_qp_index_offset = read_exp_golomb_s(buf);
-    pps->deblocking_filter_control_present_flag = read_bits(buf, 1);
-    pps->constrained_intra_pred_flag = read_bits(buf, 1);
-    pps->redundant_pic_cnt_present_flag = read_bits(buf, 1);
-
-    if(!rbsp_trailing_bits(buf)) {
-		pps->transform_8x8_mode_flag = read_bits(buf, 1);
-		pps->pic_scaling_matrix_present_flag = read_bits(buf, 1);
-		if(pps->pic_scaling_matrix_present_flag) {
-			int i;
-			for(i = 0; i < 6 + 2 * pps->transform_8x8_mode_flag; i++) {
-				pps->pic_scaling_list_present_flag[i] = read_bits(buf, 1);
-
-				if(pps->pic_scaling_list_present_flag[i]) {
-					if(i < 6)
-						parse_scaling_list(buf, pps->scaling_lists_4x4[i], 16, i);
-					else
-						parse_scaling_list(buf, pps->scaling_lists_8x8[i-6], 64, i);
-				}
-			}
-		}
-
-		pps->second_chroma_qp_index_offset = read_exp_golomb_s(buf);
-    }
-
-    return 0;
-}
-
-uint8_t parse_slice_header(struct buf_reader *buf, struct nal_unit *nal)
-{
-    struct seq_parameter_set_rbsp *sps = nal->sps;
-    struct pic_parameter_set_rbsp *pps = nal->pps;
-    struct slice_header *slc = nal->slc;
-    if(!sps || !pps)
-        return -1;
-
-    slc->first_mb_in_slice = read_exp_golomb(buf);
-    slc->slice_type = read_exp_golomb(buf);
-    slc->pic_parameter_set_id = read_exp_golomb(buf);
-    slc->frame_num = read_bits(buf, sps->log2_max_frame_num_minus4 + 4);
-    if(!sps->frame_mbs_only_flag) {
-        slc->field_pic_flag = read_bits(buf, 1);
-        if(slc->field_pic_flag)
-            slc->bottom_field_flag = read_bits(buf, 1);
-        else
-            slc->bottom_field_flag = -1;
-    } else {
-        slc->field_pic_flag = 0;
-        slc->bottom_field_flag = -1;
-    }
-
-    if(nal->nal_unit_type == NAL_SLICE_IDR)
-        slc->idr_pic_id = read_exp_golomb(buf);
-
-    if(!sps->pic_order_cnt_type) {
-        slc->pic_order_cnt_lsb = read_bits(buf, sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
-        if(pps->pic_order_present_flag && !slc->field_pic_flag)
-            slc->delta_pic_order_cnt_bottom = read_exp_golomb_s(buf);
-    } else if (sps->pic_order_cnt_type == 1) {
-        slc->delta_pic_order_cnt[0] = read_exp_golomb_s(buf);
-        if(pps->pic_order_present_flag && !slc->field_pic_flag)
-            slc->delta_pic_order_cnt[1] = read_exp_golomb_s(buf);
-    }
-    /* do not need more information for packetizing */
-
-    return 0;
-}
-
-
-
-/* ----------------- NAL parser ----------------- */
-
-struct nal_parser* init_parser()
-{
-    struct nal_parser *parser = malloc(sizeof(struct nal_parser));
-    memset(parser->buf, 0x00, MAX_FRAME_SIZE);
-    parser->buf_len = 0;
-    parser->found_sps = 0;
-    parser->found_pps = 0;
-    parser->nal0 = malloc(sizeof(struct nal_unit));
-    memset(parser->nal0, 0x00, sizeof(struct nal_unit));
-    parser->nal1 = malloc(sizeof(struct nal_unit));
-    memset(parser->nal1, 0x00, sizeof(struct nal_unit));
-    parser->current_nal = parser->nal0;
-    parser->last_nal = parser->nal1;
-
-    parser->last_nal_res = 0;
-    parser->slice = 0;
-    parser->field = -1;
-    parser->have_top = 0;
-
-    return parser;
-}
-
-void free_parser(struct nal_parser *parser)
-{
-    free(parser->nal0);
-    free(parser->nal1);
-    free(parser);
-}
-
-int parse_frame(struct nal_parser *parser, uint8_t *inbuf, int inbuf_len,
-                uint8_t **ret_buf, int *ret_len)
-{
-    int next_nal;
-    int parsed_len = 0;
-    int search_offset = 0;
-
-    while((next_nal = seek_for_nal(inbuf+search_offset, inbuf_len-parsed_len)) >= 0) {
-        // save buffer up to the nal-start
-        if(parser->buf_len + next_nal + search_offset > MAX_FRAME_SIZE) {
-            printf("buf underrun!!\n");
-            *ret_len = 0;
-            *ret_buf = NULL;
-            return parsed_len;
-        }
-        //if(parser->last_nal_res != 1) {
-            xine_fast_memcpy(&parser->buf[parser->buf_len], inbuf, next_nal+search_offset);
-            parser->buf_len += next_nal+search_offset;
-        //}
-        inbuf += next_nal+search_offset;
-        parsed_len += next_nal+search_offset;
-
-        if((parser->last_nal_res = parse_nal(inbuf+4, inbuf_len-parsed_len, parser)) == 1
-            && parser->buf_len>0) {
-            // parse_nal returned 1 --> detected a frame_boundary
-            *ret_buf = malloc(parser->buf_len);
-            xine_fast_memcpy(*ret_buf, parser->buf, parser->buf_len);
-            *ret_len = parser->buf_len;
-
-            //memset(parser->buf, 0x00, parser->buf_len);
-            parser->buf_len = 0;
-            parser->last_nal_res = 0;
-            return parsed_len;
-        }
-
-        search_offset = 4;
-    }
-
-    // no further NAL found, copy the rest of the stream
-    // into the buffer
-//    if(parser->last_nal_res != 1) {
-        xine_fast_memcpy(&parser->buf[parser->buf_len], inbuf, inbuf_len-parsed_len);
-        parser->buf_len += inbuf_len-parsed_len;
-//    }
-
-    parsed_len += (inbuf_len-parsed_len);
-    *ret_len = 0;
-    *ret_buf = NULL;
-
-    return parsed_len;
-}
-
-int parse_nal(uint8_t *buf, int buf_len, struct nal_parser *parser)
-{
-    struct buf_reader bufr;
-
-    bufr.buf = buf;
-    bufr.cur_pos = buf;
-    bufr.cur_offset = 8;
-    bufr.len = buf_len;
-
-    struct nal_unit *nal = parser->current_nal;
-    struct nal_unit *last_nal = parser->last_nal;
-
-    int res = parse_nal_header(&bufr, nal);
-
-    if(res >= NAL_SLICE && res <= NAL_SLICE_IDR) {
-        // now detect if it's a new frame!
-        int ret = 0;
-        if(nal->slc->field_pic_flag == 1)
-            parser->field = nal->slc->bottom_field_flag;
-        else {
-            parser->have_top = 1;
-            parser->field = -1;
-        }
-
-        if(nal->slc->field_pic_flag == 1 && nal->slc->bottom_field_flag == 0)
-            parser->have_top = 1;
-
-        parser->slice = 1;
-
-        if(nal->slc == NULL || last_nal->slc == NULL) {
-            ret = 1;
-        }
-        if(nal->slc && last_nal->slc &&
-           (nal->slc->frame_num != last_nal->slc->frame_num)) {
-            ret = 1;
-        }
-        if(nal->slc && last_nal->slc &&
-           (nal->slc->pic_parameter_set_id != last_nal->slc->pic_parameter_set_id)) {
-            ret = 1;
-        }
-        if(nal->slc && last_nal->slc &&
-           (nal->slc->field_pic_flag != last_nal->slc->field_pic_flag)) {
-            ret = 1;
-        }
-        if(nal->slc && last_nal->slc &&
-           (nal->slc->bottom_field_flag != -1 &&
-                last_nal->slc->bottom_field_flag != -1 &&
-                nal->slc->bottom_field_flag != last_nal->slc->bottom_field_flag)) {
-            ret = 1;
-        }
-        if(nal->nal_ref_idc != last_nal->nal_ref_idc &&
-                (nal->nal_ref_idc == 0 || last_nal->nal_ref_idc == 0)) {
-            ret = 1;
-        }
-        if(nal->sps && nal->slc && last_nal->slc &&
-           (nal->sps->pic_order_cnt_type == 0 &&
-                (nal->slc->pic_order_cnt_lsb != last_nal->slc->pic_order_cnt_lsb ||
-                 nal->slc->delta_pic_order_cnt_bottom != last_nal->slc->delta_pic_order_cnt_bottom))) {
-            ret = 1;
-        }
-        if(nal->slc && last_nal->slc &&
-           (nal->sps->pic_order_cnt_type == 1 &&
-                (nal->slc->delta_pic_order_cnt[0] != last_nal->slc->delta_pic_order_cnt[0] ||
-                nal->slc->delta_pic_order_cnt[1] != last_nal->slc->delta_pic_order_cnt[1]))) {
-            ret = 1;
-        }
-        if(nal->nal_unit_type != last_nal->nal_unit_type &&
-                (nal->nal_unit_type == 5 || last_nal->nal_unit_type == 5)) {
-            ret = 1;
-        }
-        if(nal->slc && last_nal->slc &&
-           (nal->nal_unit_type == 5 && last_nal->nal_unit_type == 5 &&
-                nal->slc->idr_pic_id != last_nal->slc->idr_pic_id)) {
-            ret = 1;
-        }
-
-        if(parser->current_nal == parser->nal0) {
-            parser->current_nal = parser->nal1;
-            parser->last_nal = parser->nal0;
-        }
-        else {
-            parser->current_nal = parser->nal0;
-            parser->last_nal = parser->nal1;
-        }
-        if(parser->current_nal->sps == NULL)
-            parser->current_nal->sps = parser->last_nal->sps;
-        if(parser->current_nal->pps == NULL)
-            parser->current_nal->pps = parser->last_nal->pps;
-
-        /*if(ret)
-            parser->slice = 0;*/
-        /*if(parser->slice && parser->have_top && parser->field != 0) {
-            parser->have_frame = 1;
-            parser->have_top = 0;
-            parser->slice = 0;
-            return ret;
-        }*/
-        return 0;
-    } else if(res == NAL_PPS || res == NAL_SPS) {
-        return 1;
-    } else if (res == NAL_AU_DELIMITER || res == NAL_SEI ||
-               (res >= 13 && res <= 18)) {
-        //printf("New Frame\n");
-        return 1;
-    }
-
-    return 0;
-}
-
-int seek_for_nal(uint8_t *buf, int buf_len)
-{
-    int i;
-    for(i=0; i<buf_len-3; i++) {
-        if(buf[i] == 0x00 && buf[i+1] == 0x00 &&
-           buf[i+2] == 0x00 && buf[i+3] == 0x01) {
-            //printf("found nal at: %d\n", i);
-            return i;
-           }
-    }
-
-    return -1;
-}
diff --git a/src/libxinevdec/nal_parser.h b/src/libxinevdec/nal_parser.h
deleted file mode 100644
index 530f6db3e..000000000
--- a/src/libxinevdec/nal_parser.h
+++ /dev/null
@@ -1,215 +0,0 @@
-#ifndef NAL_PARSER_H_
-#define NAL_PARSER_H_
-
-#include <stdlib.h>
-
-#include "xine_internal.h"
-
-enum nal_unit_types {
-    NAL_UNSPECIFIED = 0,
-    NAL_SLICE,
-    NAL_PART_A,
-    NAL_PART_B,
-    NAL_PART_C,
-    NAL_SLICE_IDR,
-    NAL_SEI,
-    NAL_SPS,
-    NAL_PPS,
-    NAL_AU_DELIMITER,
-    NAL_END_OF_SEQUENCE,
-    NAL_END_OF_STREAM,
-    NAL_FILLER_DATA,
-    NAL_SPS_EXT
-};
-
-/* default scaling_lists according to Table 7-2 */
-uint8_t default_4x4_intra[16] =
-	{ 6, 13, 13, 20, 20, 20, 28, 28, 28, 28, 32, 32, 32, 37, 37, 42 };
-
-uint8_t default_4x4_inter[16] =
-	{ 10, 14, 14, 20, 20, 20, 24, 24, 24, 24, 27, 27, 27, 30, 30, 34};
-
-uint8_t default_8x8_intra[64] =
-	{ 6, 10, 10, 13, 11, 13, 16, 16, 16, 16, 18, 18, 18, 18, 18, 32,
-	  23, 23, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27,
-	  27, 27, 27, 27, 29, 29, 29, 29, 29, 29, 29, 31, 31, 31, 31, 31,
-	  31, 33, 33, 33, 33, 33, 36, 36, 36, 36, 38, 38, 38, 40, 40, 42 };
-
-uint8_t default_8x8_inter[64] =
-	{ 9, 13, 13, 15, 13, 15, 17, 17, 17, 17, 19, 19, 19, 19, 19, 21,
-	  21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 24, 24, 24, 24,
-	  24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27,
-	  27, 28, 28, 28, 28, 28, 30, 30, 30, 30, 32, 32, 32, 33, 33, 35 };
-
-
-struct nal_unit {
-    uint8_t     nal_ref_idc;    // 0x03
-    uint8_t     nal_unit_type;  // 0x1f
-
-    struct seq_parameter_set_rbsp   *sps;
-    struct pic_parameter_set_rbsp   *pps;
-    struct slice_header             *slc;
-};
-
-struct seq_parameter_set_rbsp {
-    uint8_t     profile_idc;            // 0xff
-    uint8_t     constraint_setN_flag;   // 0x0f
-    uint8_t     level_idc;              // 0xff
-    uint32_t    seq_parameter_set_id;
-    uint32_t    chroma_format_idc;
-    uint8_t     residual_colour_transform_flag;  // 0x01
-    uint32_t    bit_depth_luma_minus8;
-    uint32_t    bit_depth_chroma_minus8;
-    uint8_t     qpprime_y_zero_transform_bypass_flag;
-    uint8_t     seq_scaling_matrix_present_flag;
-
-    /* if(seq_scaling_matrix_present_flag) */
-	{
-		uint8_t 	seq_scaling_list_present_flag[8];
-
-		uint8_t		scaling_lists_4x4[6][16];
-		uint8_t		scaling_lists_8x8[2][64];
-	}
-
-    uint32_t    log2_max_frame_num_minus4;
-    uint32_t    pic_order_cnt_type;
-    // if pic_order_cnt_type==0
-    uint32_t    log2_max_pic_order_cnt_lsb_minus4;
-    // else
-    uint8_t     delta_pic_order_always_zero_flag;
-    int32_t     offset_for_non_ref_pic;
-    int32_t     offset_for_top_to_bottom_field;
-    uint8_t     num_ref_frames_in_pic_order_cnt_cycle;
-    int32_t     offset_for_ref_frame[256];
-    // TODO: some more ignored here
-    uint32_t    num_ref_frames;
-    uint8_t     gaps_in_frame_num_value_allowed_flag;
-    /*uint32_t    pic_width_in_mbs_minus1;
-    uint32_t    pic_height_in_map_units_minus1;*/
-    uint32_t    pic_width;
-    uint32_t    pic_height;
-    uint8_t     frame_mbs_only_flag;
-    uint8_t     mb_adaptive_frame_field_flag;
-    uint8_t     direct_8x8_inference_flag;
-    uint8_t     frame_cropping_flag;
-    uint32_t    frame_crop_left_offset;
-    uint32_t    frame_crop_right_offset;
-    uint32_t    frame_crop_top_offset;
-    uint32_t    frame_crop_bottom_offset;
-    uint8_t     vui_parameters_present_flag;
-    // TODO: add vui_parameters, rtbsp_trailing_bits
-
-};
-
-struct pic_parameter_set_rbsp {
-    uint32_t    pic_parameter_set_id;
-    uint32_t    seq_parameter_set_id;
-    uint8_t     entropy_coding_mode_flag;
-    uint8_t     pic_order_present_flag;
-
-    uint32_t	num_slice_groups_minus1;
-
-    /* num_slice_groups_minus1 > 0 */
-    {
-        uint32_t	slice_group_map_type;
-
-		/* slice_group_map_type == 1 */
-		{
-			uint32_t	run_length_minus1[64];
-		}
-
-		/* slice_group_map_type == 2 */
-		{
-			uint32_t	top_left[64];
-			uint32_t	bottom_right[64];
-		}
-
-		/* slice_group_map_type == 3,4,5 */
-		{
-			uint8_t		slice_group_change_direction_flag;
-			uint32_t	slice_group_change_rate_minus1;
-		}
-
-		/* slice_group_map_type == 6 */
-		{
-			uint32_t	pic_size_in_map_units_minus1;
-			uint8_t		slice_group_id[64];
-		}
-    }
-
-    uint32_t	num_ref_idx_l0_active_minus1;
-    uint32_t	num_ref_idx_l1_active_minus1;
-    uint8_t		weighted_pred_flag;
-    uint8_t		weighted_bipred_idc;
-    int32_t		pic_init_qp_minus26;
-    int32_t		pic_init_qs_minus26;
-    int32_t		chroma_qp_index_offset;
-    uint8_t		deblocking_filter_control_present_flag;
-    uint8_t		constrained_intra_pred_flag;
-    uint8_t		redundant_pic_cnt_present_flag;
-
-    /* if(more_rbsp_data) */
-    uint8_t		transform_8x8_mode_flag;
-    uint8_t		pic_scaling_matrix_present_flag;
-
-    /* if(pic_scaling_matrix_present_flag) */
-    {
-    	uint8_t 	pic_scaling_list_present_flag[8];
-
-    	uint8_t		scaling_lists_4x4[6][16];
-    	uint8_t		scaling_lists_8x8[2][64];
-
-    	int32_t		second_chroma_qp_index_offset;
-    }
-};
-
-struct slice_header {
-    uint32_t    first_mb_in_slice;
-    uint32_t    slice_type;
-    uint32_t    pic_parameter_set_id;
-    uint32_t    frame_num;
-    int8_t      field_pic_flag;
-    int8_t      bottom_field_flag;
-    uint32_t    idr_pic_id;
-
-    /* sps->pic_order_cnt_type == 0 */
-    uint32_t    pic_order_cnt_lsb;
-    int32_t     delta_pic_order_cnt_bottom;
-    /* sps->pic_order_cnt_type == 1 && !sps->delta_pic_order_always_zero_flag */
-    int32_t     delta_pic_order_cnt[2];
-
-    /* not needed for packetizing */
-    /*int32_t     redundant_pic_cnt;
-    uint8_t     direct_spatial_mv_pred_flag;*/
-
-};
-
-
-#define MAX_FRAME_SIZE  1024*1024
-
-struct nal_parser {
-    uint8_t buf[MAX_FRAME_SIZE];
-    int buf_len;
-    int found_sps;
-    int found_pps;
-    int last_nal_res;
-    int field; // 0=top, 1=bottom, -1=both
-    int slice;
-    int have_top;
-    int have_frame;
-    struct nal_unit *nal0;
-    struct nal_unit *nal1;
-    struct nal_unit *current_nal;
-    struct nal_unit *last_nal;
-};
-
-int parse_nal(uint8_t *buf, int buf_len, struct nal_parser *parser);
-
-int seek_for_nal(uint8_t *buf, int buf_len);
-
-struct nal_parser* init_parser();
-void free_parser(struct nal_parser *parser);
-int parse_frame(struct nal_parser *parser, uint8_t *inbuf, int inbuf_len,
-                uint8_t **ret_buf, int *ret_len);
-
-#endif