av_cold int swri_rematrix_init(SwrContext *s){

    int i, j;

    int nb_in  = av_get_channel_layout_nb_channels(s->in_ch_layout);

    int nb_out = av_get_channel_layout_nb_channels(s->out_ch_layout);

    s->mix_any_f = NULL;

    if (!s->rematrix_custom) {

        int r = auto_matrix(s);

        if (r)

            return r;

    }

    if (s->midbuf.fmt == AV_SAMPLE_FMT_S16P){

        s->native_matrix = av_calloc(nb_in * nb_out, sizeof(int));

        s->native_one    = av_mallocz(sizeof(int));

        for (i = 0; i < nb_out; i++)

            for (j = 0; j < nb_in; j++)

                ((int*)s->native_matrix)[i * nb_in + j] = lrintf(s->matrix[i][j] * 32768);

        *((int*)s->native_one) = 32768;

        s->mix_1_1_f = (mix_1_1_func_type*)copy_s16;

        s->mix_2_1_f = (mix_2_1_func_type*)sum2_s16;

        s->mix_any_f = (mix_any_func_type*)get_mix_any_func_s16(s);

    }else if(s->midbuf.fmt == AV_SAMPLE_FMT_FLTP){

        s->native_matrix = av_calloc(nb_in * nb_out, sizeof(float));

        s->native_one    = av_mallocz(sizeof(float));

        for (i = 0; i < nb_out; i++)

            for (j = 0; j < nb_in; j++)

                ((float*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];

        *((float*)s->native_one) = 1.0;

        s->mix_1_1_f = (mix_1_1_func_type*)copy_float;

        s->mix_2_1_f = (mix_2_1_func_type*)sum2_float;

        s->mix_any_f = (mix_any_func_type*)get_mix_any_func_float(s);

    }else if(s->midbuf.fmt == AV_SAMPLE_FMT_DBLP){

        s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));

        s->native_one    = av_mallocz(sizeof(double));

        for (i = 0; i < nb_out; i++)

            for (j = 0; j < nb_in; j++)

                ((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];

        *((double*)s->native_one) = 1.0;

        s->mix_1_1_f = (mix_1_1_func_type*)copy_double;

        s->mix_2_1_f = (mix_2_1_func_type*)sum2_double;

        s->mix_any_f = (mix_any_func_type*)get_mix_any_func_double(s);

    }else if(s->midbuf.fmt == AV_SAMPLE_FMT_S32P){

        // Only for dithering currently

//         s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));

        s->native_one    = av_mallocz(sizeof(int));

//         for (i = 0; i < nb_out; i++)

//             for (j = 0; j < nb_in; j++)

//                 ((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];

        *((int*)s->native_one) = 32768;

        s->mix_1_1_f = (mix_1_1_func_type*)copy_s32;

        s->mix_2_1_f = (mix_2_1_func_type*)sum2_s32;

        s->mix_any_f = (mix_any_func_type*)get_mix_any_func_s32(s);

    }else

        av_assert0(0);

    //FIXME quantize for integeres

    for (i = 0; i < SWR_CH_MAX; i++) {

        int ch_in=0;

        for (j = 0; j < SWR_CH_MAX; j++) {

            s->matrix32[i][j]= lrintf(s->matrix[i][j] * 32768);

            if(s->matrix[i][j])

                s->matrix_ch[i][++ch_in]= j;

        }

        s->matrix_ch[i][0]= ch_in;

    }

    if(HAVE_YASM && HAVE_MMX) swri_rematrix_init_x86(s);

    return 0;

}


static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)

{

    int i, j, k, sb_x, sb_y;

    int scheme;

    int current_macroblock;

    int current_fragment;

    int coding_mode;

    int custom_mode_alphabet[CODING_MODE_COUNT];

    if (s->keyframe) {

        for (i = 0; i < s->fragment_count; i++)

            s->all_fragments[i].coding_method = MODE_INTRA;

    } else {

        /* fetch the mode coding scheme for this frame */

        scheme = get_bits(gb, 3);

        /* is it a custom coding scheme? */

        if (scheme == 0) {

            for (i = 0; i < 8; i++)

                custom_mode_alphabet[i] = MODE_INTER_NO_MV;

            for (i = 0; i < 8; i++)

                custom_mode_alphabet[get_bits(gb, 3)] = i;

        }

        /* iterate through all of the macroblocks that contain 1 or more

         * coded fragments */

        for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {

            for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {

            for (j = 0; j < 4; j++) {

                int mb_x = 2*sb_x +   (j>>1);

                int mb_y = 2*sb_y + (((j>>1)+j)&1);

                int frags_coded = 0;

                current_macroblock = mb_y * s->macroblock_width + mb_x;

                if (mb_x >= s->macroblock_width || mb_y >= s->macroblock_height)

                    continue;

#define BLOCK_X (2*mb_x + (k&1))

#define BLOCK_Y (2*mb_y + (k>>1))

                /* coding modes are only stored if the macroblock has at least one

                 * luma block coded, otherwise it must be INTER_NO_MV */

                for (k = 0; k < 4; k++) {

                    current_fragment = BLOCK_Y*s->fragment_width + BLOCK_X;

                    if (s->all_fragments[current_fragment].coding_method != MODE_COPY)

                        break;

                }

                if (k == 4) {

                    s->macroblock_coding[current_macroblock] = MODE_INTER_NO_MV;

                    continue;

                }

                /* mode 7 means get 3 bits for each coding mode */

                if (scheme == 7)

                    coding_mode = get_bits(gb, 3);

                else if(scheme == 0)

                    coding_mode = custom_mode_alphabet

                        [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];

                else

                    coding_mode = ModeAlphabet[scheme-1]

                        [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];

                s->macroblock_coding[current_macroblock] = coding_mode;

                for (k = 0; k < 4; k++) {

                    current_fragment =

                        BLOCK_Y*s->fragment_width + BLOCK_X;

                    if (s->all_fragments[current_fragment].coding_method !=

                        MODE_COPY)

                        s->all_fragments[current_fragment].coding_method =

                            coding_mode;

                }

                for (k = 0; k < 2; k++) {

                    current_fragment = s->fragment_start[k+1] +

                        mb_y*(s->fragment_width>>1) + mb_x;

                    if (s->all_fragments[current_fragment].coding_method !=

                        MODE_COPY)

                        s->all_fragments[current_fragment].coding_method =

                            coding_mode;

                }

            }

            }

        }

    }

    return 0;

}


static int h264_probe(AVProbeData *p)

{

    uint32_t code = -1;

    int sps = 0, pps = 0, idr = 0, res = 0, sli = 0;

    int i;

    for (i = 0; i < p->buf_size; i++) {

        code = (code << 8) + p->buf[i];

        if ((code & 0xffffff00) == 0x100) {

            int ref_idc = (code >> 5) & 3;

            int type    = code & 0x1F;

            static const int8_t ref_zero[] = {

                 2,  0,  0,  0,  0, -1,  1, -1,

                -1,  1,  1,  1,  1, -1,  2,  2,

                 2,  2,  2,  0,  2,  2,  2,  2,

                 2,  2,  2,  2,  2,  2,  2,  2

            };

            if (code & 0x80) // forbidden_bit

                return 0;

            if (ref_zero[type] == 1 && ref_idc)

                return 0;

            if (ref_zero[type] == -1 && !ref_idc)

                return 0;

            if (ref_zero[type] == 2) {

                if (!(code == 0x100 && !p->buf[i + 1] && !p->buf[i + 2]))

                    res++;

            }

            switch (type) {

            case 1:

                sli++;

                break;

            case 5:

                idr++;

                break;

            case 7:

                if (p->buf[i + 2] & 0x03)

                    return 0;

                sps++;

                break;

            case 8:

                pps++;

                break;

            }

        }

    }

    ff_tlog(NULL, "sps:%d pps:%d idr:%d sli:%d res:%d\n", sps, pps, idr, sli, res);

    if (sps && pps && (idr || sli > 3) && res < (sps + pps + idr))

        return AVPROBE_SCORE_EXTENSION + 1;  // 1 more than .mpg

    return 0;

}


static int mov_write_tapt_tag(AVIOContext *pb, MOVTrack *track)

{

    int32_t width = av_rescale(track->enc->sample_aspect_ratio.num, track->enc->width,

                               track->enc->sample_aspect_ratio.den);

    int64_t pos = avio_tell(pb);

    avio_wb32(pb, 0); /* size */

    ffio_wfourcc(pb, "tapt");

    avio_wb32(pb, 20);

    ffio_wfourcc(pb, "clef");

    avio_wb32(pb, 0);

    avio_wb32(pb, width << 16);

    avio_wb32(pb, track->enc->height << 16);

    avio_wb32(pb, 20);

    ffio_wfourcc(pb, "enof");

    avio_wb32(pb, 0);

    avio_wb32(pb, track->enc->width << 16);

    avio_wb32(pb, track->enc->height << 16);

    return updateSize(pb, pos);

};


static inline void RENAME(rgb24ToUV_half)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, long width, uint32_t *unused)

{

    int i;

    assert(src1==src2);

    for (i=0; i<width; i++) {

        int r= src1[6*i + 0] + src1[6*i + 3];

        int g= src1[6*i + 1] + src1[6*i + 4];

        int b= src1[6*i + 2] + src1[6*i + 5];

        dstU[i]= (RU*r + GU*g + BU*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

        dstV[i]= (RV*r + GV*g + BV*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);

    }

}


static inline int parse_nal_units(AVCodecParserContext *s,

                                  AVCodecContext *avctx,

                                  const uint8_t * const buf, int buf_size)

{

    H264ParseContext *p = s->priv_data;

    H2645NAL nal = { NULL };

    int buf_index, next_avc;

    unsigned int pps_id;

    unsigned int slice_type;

    int state = -1, got_reset = 0;

    int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);

    int field_poc[2];

    int ret;

    /* set some sane default values */

    s->pict_type         = AV_PICTURE_TYPE_I;

    s->key_frame         = 0;

    s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;

    ff_h264_sei_uninit(&p->sei);

    p->sei.frame_packing.frame_packing_arrangement_cancel_flag = -1;

    if (!buf_size)

        return 0;

    buf_index     = 0;

    next_avc      = p->is_avc ? 0 : buf_size;

    for (;;) {

        const SPS *sps;

        int src_length, consumed, nalsize = 0;

        if (buf_index >= next_avc) {

            nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx);

            if (nalsize < 0)

                break;

            next_avc = buf_index + nalsize;

        } else {

            buf_index = find_start_code(buf, buf_size, buf_index, next_avc);

            if (buf_index >= buf_size)

                break;

            if (buf_index >= next_avc)

                continue;

        }

        src_length = next_avc - buf_index;

        state = buf[buf_index];

        switch (state & 0x1f) {

        case H264_NAL_SLICE:

        case H264_NAL_IDR_SLICE:

            // Do not walk the whole buffer just to decode slice header

            if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {

                /* IDR or disposable slice

                 * No need to decode many bytes because MMCOs shall not be present. */

                if (src_length > 60)

                    src_length = 60;

            } else {

                /* To decode up to MMCOs */

                if (src_length > 1000)

                    src_length = 1000;

            }

            break;

        }

        consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &nal, 1);

        if (consumed < 0)

            break;

        buf_index += consumed;

        ret = init_get_bits8(&nal.gb, nal.data, nal.size);

        if (ret < 0)

            goto fail;

        get_bits1(&nal.gb);

        nal.ref_idc = get_bits(&nal.gb, 2);

        nal.type    = get_bits(&nal.gb, 5);

        switch (nal.type) {

        case H264_NAL_SPS:

            ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0);

            break;

        case H264_NAL_PPS:

            ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,

                                                 nal.size_bits);

            break;

        case H264_NAL_SEI:

            ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);

            break;

        case H264_NAL_IDR_SLICE:

            s->key_frame = 1;

            p->poc.prev_frame_num        = 0;

            p->poc.prev_frame_num_offset = 0;

            p->poc.prev_poc_msb          =

            p->poc.prev_poc_lsb          = 0;

        /* fall through */

        case H264_NAL_SLICE:

            get_ue_golomb_long(&nal.gb);  // skip first_mb_in_slice

            slice_type   = get_ue_golomb_31(&nal.gb);

            s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];

            if (p->sei.recovery_point.recovery_frame_cnt >= 0) {

                /* key frame, since recovery_frame_cnt is set */

                s->key_frame = 1;

            }

            pps_id = get_ue_golomb(&nal.gb);

            if (pps_id >= MAX_PPS_COUNT) {

                av_log(avctx, AV_LOG_ERROR,

                       "pps_id %u out of range\n", pps_id);

                goto fail;

            }

            if (!p->ps.pps_list[pps_id]) {

                av_log(avctx, AV_LOG_ERROR,

                       "non-existing PPS %u referenced\n", pps_id);

                goto fail;

            }

            av_buffer_unref(&p->ps.pps_ref);

            av_buffer_unref(&p->ps.sps_ref);

            p->ps.pps = NULL;

            p->ps.sps = NULL;

            p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]);

            if (!p->ps.pps_ref)

                goto fail;

            p->ps.pps = (const PPS*)p->ps.pps_ref->data;

            if (!p->ps.sps_list[p->ps.pps->sps_id]) {

                av_log(avctx, AV_LOG_ERROR,

                       "non-existing SPS %u referenced\n", p->ps.pps->sps_id);

                goto fail;

            }

            p->ps.sps_ref = av_buffer_ref(p->ps.sps_list[p->ps.pps->sps_id]);

            if (!p->ps.sps_ref)

                goto fail;

            p->ps.sps = (const SPS*)p->ps.sps_ref->data;

            sps = p->ps.sps;

            // heuristic to detect non marked keyframes

            if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)

                s->key_frame = 1;

            p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);

            s->coded_width  = 16 * sps->mb_width;

            s->coded_height = 16 * sps->mb_height;

            s->width        = s->coded_width  - (sps->crop_right + sps->crop_left);

            s->height       = s->coded_height - (sps->crop_top   + sps->crop_bottom);

            if (s->width <= 0 || s->height <= 0) {

                s->width  = s->coded_width;

                s->height = s->coded_height;

            }

            switch (sps->bit_depth_luma) {

            case 9:

                if (sps->chroma_format_idc == 3)      s->format = AV_PIX_FMT_YUV444P9;

                else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9;

                else                                  s->format = AV_PIX_FMT_YUV420P9;

                break;

            case 10:

                if (sps->chroma_format_idc == 3)      s->format = AV_PIX_FMT_YUV444P10;

                else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10;

                else                                  s->format = AV_PIX_FMT_YUV420P10;

                break;

            case 8:

                if (sps->chroma_format_idc == 3)      s->format = AV_PIX_FMT_YUV444P;

                else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P;

                else                                  s->format = AV_PIX_FMT_YUV420P;

                break;

            default:

                s->format = AV_PIX_FMT_NONE;

            }

            avctx->profile = ff_h264_get_profile(sps);

            avctx->level   = sps->level_idc;

            if (sps->frame_mbs_only_flag) {

                p->picture_structure = PICT_FRAME;

            } else {

                if (get_bits1(&nal.gb)) { // field_pic_flag

                    p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag

                } else {

                    p->picture_structure = PICT_FRAME;

                }

            }

            if (nal.type == H264_NAL_IDR_SLICE)

                get_ue_golomb_long(&nal.gb); /* idr_pic_id */

            if (sps->poc_type == 0) {

                p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);

                if (p->ps.pps->pic_order_present == 1 &&

                    p->picture_structure == PICT_FRAME)

                    p->poc.delta_poc_bottom = get_se_golomb(&nal.gb);

            }

            if (sps->poc_type == 1 &&

                !sps->delta_pic_order_always_zero_flag) {

                p->poc.delta_poc[0] = get_se_golomb(&nal.gb);

                if (p->ps.pps->pic_order_present == 1 &&

                    p->picture_structure == PICT_FRAME)

                    p->poc.delta_poc[1] = get_se_golomb(&nal.gb);

            }

            /* Decode POC of this picture.

             * The prev_ values needed for decoding POC of the next picture are not set here. */

            field_poc[0] = field_poc[1] = INT_MAX;

            ff_h264_init_poc(field_poc, &s->output_picture_number, sps,

                             &p->poc, p->picture_structure, nal.ref_idc);

            /* Continue parsing to check if MMCO_RESET is present.

             * FIXME: MMCO_RESET could appear in non-first slice.

             *        Maybe, we should parse all undisposable non-IDR slice of this

             *        picture until encountering MMCO_RESET in a slice of it. */

            if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) {

                got_reset = scan_mmco_reset(s, &nal.gb, avctx);

                if (got_reset < 0)

                    goto fail;

            }

            /* Set up the prev_ values for decoding POC of the next picture. */

            p->poc.prev_frame_num        = got_reset ? 0 : p->poc.frame_num;

            p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset;

            if (nal.ref_idc != 0) {

                if (!got_reset) {

                    p->poc.prev_poc_msb = p->poc.poc_msb;

                    p->poc.prev_poc_lsb = p->poc.poc_lsb;

                } else {

                    p->poc.prev_poc_msb = 0;

                    p->poc.prev_poc_lsb =

                        p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];

                }

            }

            if (sps->pic_struct_present_flag) {

                switch (p->sei.picture_timing.pic_struct) {

                case SEI_PIC_STRUCT_TOP_FIELD:

                case SEI_PIC_STRUCT_BOTTOM_FIELD:

                    s->repeat_pict = 0;

                    break;

                case SEI_PIC_STRUCT_FRAME:

                case SEI_PIC_STRUCT_TOP_BOTTOM:

                case SEI_PIC_STRUCT_BOTTOM_TOP:

                    s->repeat_pict = 1;

                    break;

                case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

                case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

                    s->repeat_pict = 2;

                    break;

                case SEI_PIC_STRUCT_FRAME_DOUBLING:

                    s->repeat_pict = 3;

                    break;

                case SEI_PIC_STRUCT_FRAME_TRIPLING:

                    s->repeat_pict = 5;

                    break;

                default:

                    s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;

                    break;

                }

            } else {

                s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;

            }

            if (p->picture_structure == PICT_FRAME) {

                s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;

                if (sps->pic_struct_present_flag) {

                    switch (p->sei.picture_timing.pic_struct) {

                    case SEI_PIC_STRUCT_TOP_BOTTOM:

                    case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

                        s->field_order = AV_FIELD_TT;

                        break;

                    case SEI_PIC_STRUCT_BOTTOM_TOP:

                    case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

                        s->field_order = AV_FIELD_BB;

                        break;

                    default:

                        s->field_order = AV_FIELD_PROGRESSIVE;

                        break;

                    }

                } else {

                    if (field_poc[0] < field_poc[1])

                        s->field_order = AV_FIELD_TT;

                    else if (field_poc[0] > field_poc[1])

                        s->field_order = AV_FIELD_BB;

                    else

                        s->field_order = AV_FIELD_PROGRESSIVE;

                }

            } else {

                if (p->picture_structure == PICT_TOP_FIELD)

                    s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;

                else

                    s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;

                if (p->poc.frame_num == p->last_frame_num &&

                    p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN &&

                    p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME &&

                    p->last_picture_structure != s->picture_structure) {

                    if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD)

                        s->field_order = AV_FIELD_TT;

                    else

                        s->field_order = AV_FIELD_BB;

                } else {

                    s->field_order = AV_FIELD_UNKNOWN;

                }

                p->last_picture_structure = s->picture_structure;

                p->last_frame_num = p->poc.frame_num;

            }

            av_freep(&nal.rbsp_buffer);

            return 0; /* no need to evaluate the rest */

        }

    }

    if (q264) {

        av_freep(&nal.rbsp_buffer);

        return 0;

    }

    /* didn't find a picture! */

    av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);

fail:

    av_freep(&nal.rbsp_buffer);

    return -1;

}


static void balloon_stats_change_timer(VirtIOBalloon *s, int secs)

{

    timer_mod(s->stats_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + secs * 1000);

}


static int tta_decode_init(AVCodecContext * avctx)
{
    TTAContext *s = avctx->priv_data;
    int i;
    s->avctx = avctx;
    // 30bytes includes a seektable with one frame
    if (avctx->extradata_size < 30)
    init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
    if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("TTA1")))
    {
        /* signature */
        skip_bits(&s->gb, 32);
//        if (get_bits_long(&s->gb, 32) != bswap_32(ff_get_fourcc("TTA1"))) {
//            av_log(s->avctx, AV_LOG_ERROR, "Missing magic\n");
//            return -1;
//        }
        s->flags = get_le16(&s->gb);
        if (s->flags != 1 && s->flags != 3)
        {
            av_log(s->avctx, AV_LOG_ERROR, "Invalid flags\n");
        s->is_float = (s->flags == FORMAT_FLOAT);
        avctx->channels = s->channels = get_le16(&s->gb);
        avctx->bits_per_sample = get_le16(&s->gb);
        s->bps = (avctx->bits_per_sample + 7) / 8;
        avctx->sample_rate = get_le32(&s->gb);
        if(avctx->sample_rate > 1000000){ //prevent FRAME_TIME * avctx->sample_rate from overflowing and sanity check
            av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
        s->data_length = get_le32(&s->gb);
        skip_bits(&s->gb, 32); // CRC32 of header
        if (s->is_float)
        {
            avctx->sample_fmt = SAMPLE_FMT_FLT;
            av_log(s->avctx, AV_LOG_ERROR, "Unsupported sample format. Please contact the developers.\n");
        else switch(s->bps) {
//            case 1: avctx->sample_fmt = SAMPLE_FMT_U8; break;
            case 2: avctx->sample_fmt = SAMPLE_FMT_S16; break;
//            case 3: avctx->sample_fmt = SAMPLE_FMT_S24; break;
            case 4: avctx->sample_fmt = SAMPLE_FMT_S32; break;
            default:
                av_log(s->avctx, AV_LOG_ERROR, "Invalid/unsupported sample format. Please contact the developers.\n");
        // FIXME: horribly broken, but directly from reference source
#define FRAME_TIME 1.04489795918367346939
        s->frame_length = (int)(FRAME_TIME * avctx->sample_rate);
        s->last_frame_length = s->data_length % s->frame_length;
        s->total_frames = s->data_length / s->frame_length +
                        (s->last_frame_length ? 1 : 0);
        av_log(s->avctx, AV_LOG_DEBUG, "flags: %x chans: %d bps: %d rate: %d block: %d\n",
            s->flags, avctx->channels, avctx->bits_per_sample, avctx->sample_rate,
            avctx->block_align);
        av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
            s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
        // FIXME: seek table
        for (i = 0; i < s->total_frames; i++)
            skip_bits(&s->gb, 32);
        skip_bits(&s->gb, 32); // CRC32 of seektable
        s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
    } else {
        av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
    return 0;


void show_licence(void)

{

    printf(

    "ffmpeg version " FFMPEG_VERSION "\n"

    "Copyright (c) 2000, 2001, 2002 Gerard Lantau\n"

    "This program is free software; you can redistribute it and/or modify\n"

    "it under the terms of the GNU General Public License as published by\n"

    "the Free Software Foundation; either version 2 of the License, or\n"

    "(at your option) any later version.\n"

    "\n"

    "This program is distributed in the hope that it will be useful,\n"

    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"

    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"

    "GNU General Public License for more details.\n"

    "\n"

    "You should have received a copy of the GNU General Public License\n"

    "along with this program; if not, write to the Free Software\n"

    "Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n"

    );

    exit(1);

}


static int parse_hex64(DeviceState *dev, Property *prop, const char *str)

{

    uint64_t *ptr = qdev_get_prop_ptr(dev, prop);

    if (sscanf(str, "%" PRIx64, ptr) != 1)

        return -EINVAL;

    return 0;

}


const TPMDriverOps *tpm_get_backend_driver(const char *type)

{

    int i;

    for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {

        if (!strcmp(TpmType_lookup[be_drivers[i]->type], type)) {

            return be_drivers[i];

        }

    }

    return NULL;

}


static void glib_pollfds_fill(int64_t *cur_timeout)

{

    GMainContext *context = g_main_context_default();

    int timeout = 0;

    int64_t timeout_ns;

    int n;

    g_main_context_prepare(context, &max_priority);

    glib_pollfds_idx = gpollfds->len;

    n = glib_n_poll_fds;

    do {

        GPollFD *pfds;

        glib_n_poll_fds = n;

        g_array_set_size(gpollfds, glib_pollfds_idx + glib_n_poll_fds);

        pfds = &g_array_index(gpollfds, GPollFD, glib_pollfds_idx);

        n = g_main_context_query(context, max_priority, &timeout, pfds,

                                 glib_n_poll_fds);

    } while (n != glib_n_poll_fds);

    if (timeout < 0) {

        timeout_ns = -1;

    } else {

        timeout_ns = (int64_t)timeout * (int64_t)SCALE_MS;

    }

    *cur_timeout = qemu_soonest_timeout(timeout_ns, *cur_timeout);

}


static uint64_t musicpal_misc_read(void *opaque, target_phys_addr_t offset,

                                   unsigned size)

{

    switch (offset) {

    case MP_MISC_BOARD_REVISION:

        return MP_BOARD_REVISION;

    default:

        return 0;

    }

}


static void dmg_refresh_limits(BlockDriverState *bs, Error **errp)

{

    bs->request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O supported */

}


static void sigp_store_adtl_status(void *arg)

{

    SigpInfo *si = arg;

    if (!kvm_check_extension(kvm_state, KVM_CAP_S390_VECTOR_REGISTERS)) {

        set_sigp_status(si, SIGP_STAT_INVALID_ORDER);

        return;

    }

    /* cpu has to be stopped */

    if (s390_cpu_get_state(si->cpu) != CPU_STATE_STOPPED) {

        set_sigp_status(si, SIGP_STAT_INCORRECT_STATE);

        return;

    }

    /* parameter must be aligned to 1024-byte boundary */

    if (si->param & 0x3ff) {

        set_sigp_status(si, SIGP_STAT_INVALID_PARAMETER);

        return;

    }

    cpu_synchronize_state(CPU(si->cpu));

    if (kvm_s390_store_adtl_status(si->cpu, si->param)) {

        set_sigp_status(si, SIGP_STAT_INVALID_PARAMETER);

        return;

    }

    si->cc = SIGP_CC_ORDER_CODE_ACCEPTED;

}


static void rom_reset(void *unused)

{

    Rom *rom;

    QTAILQ_FOREACH(rom, &roms, next) {

        if (rom->fw_file) {

            continue;

        }

        if (rom->data == NULL)

            continue;

        cpu_physical_memory_write_rom(rom->addr, rom->data, rom->romsize);

        if (rom->isrom) {

            /* rom needs to be written only once */

            qemu_free(rom->data);

            rom->data = NULL;

        }

    }

}


static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st,

                               MPADecodeHeader *c, uint32_t spf)

{

#define LAST_BITS(k, n) ((k) & ((1 << (n)) - 1))

#define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m)))

    uint16_t crc;

    uint32_t v;

    char version[10];

    uint32_t peak   = 0;

    int32_t  r_gain = INT32_MIN, a_gain = INT32_MIN;

    MP3DecContext *mp3 = s->priv_data;

    static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};

    uint64_t fsize = avio_size(s->pb);

    /* Check for Xing / Info tag */

    avio_skip(s->pb, xing_offtbl[c->lsf == 1][c->nb_channels == 1]);

    v = avio_rb32(s->pb);

    mp3->is_cbr = v == MKBETAG('I', 'n', 'f', 'o');

    if (v != MKBETAG('X', 'i', 'n', 'g') && !mp3->is_cbr)

        return;

    v = avio_rb32(s->pb);

    if (v & XING_FLAG_FRAMES)

        mp3->frames = avio_rb32(s->pb);

    if (v & XING_FLAG_SIZE)

        mp3->header_filesize = avio_rb32(s->pb);

    if (fsize && mp3->header_filesize) {

        uint64_t min, delta;

        min = FFMIN(fsize, mp3->header_filesize);

        delta = FFMAX(fsize, mp3->header_filesize) - min;

        if (fsize > mp3->header_filesize && delta > min >> 4) {

            mp3->frames = 0;

        } else if (delta > min >> 4) {

            av_log(s, AV_LOG_WARNING,

                   "filesize and duration do not match (growing file?)\n");

        }

    }

    if (v & XING_FLAG_TOC)

        read_xing_toc(s, mp3->header_filesize, av_rescale_q(mp3->frames,

                                       (AVRational){spf, c->sample_rate},

                                       st->time_base));

    /* VBR quality */

    if(v & 8)

        avio_skip(s->pb, 4);

    /* Encoder short version string */

    memset(version, 0, sizeof(version));

    avio_read(s->pb, version, 9);

    /* Info Tag revision + VBR method */

    avio_r8(s->pb);

    /* Lowpass filter value */

    avio_r8(s->pb);

    /* ReplayGain peak */

    v    = avio_rb32(s->pb);

    peak = av_rescale(v, 100000, 1 << 23);

    /* Radio ReplayGain */

    v = avio_rb16(s->pb);

    if (MIDDLE_BITS(v, 13, 15) == 1) {

        r_gain = MIDDLE_BITS(v, 0, 8) * 10000;

        if (v & (1 << 9))

            r_gain *= -1;

    }

    /* Audiophile ReplayGain */

    v = avio_rb16(s->pb);

    if (MIDDLE_BITS(v, 13, 15) == 2) {

        a_gain = MIDDLE_BITS(v, 0, 8) * 10000;

        if (v & (1 << 9))

            a_gain *= -1;

    }

    /* Encoding flags + ATH Type */

    avio_r8(s->pb);

    /* if ABR {specified bitrate} else {minimal bitrate} */

    avio_r8(s->pb);

    /* Encoder delays */

    v= avio_rb24(s->pb);

    if(AV_RB32(version) == MKBETAG('L', 'A', 'M', 'E')

        || AV_RB32(version) == MKBETAG('L', 'a', 'v', 'f')) {

        mp3->start_pad = v>>12;

        mp3->  end_pad = v&4095;

        st->skip_samples = mp3->start_pad + 528 + 1;

        if (mp3->frames)

            st->end_discard_sample = -mp3->end_pad + 528 + 1 + mp3->frames * (int64_t)spf;

        if (!st->start_time)

            st->start_time = av_rescale_q(st->skip_samples,

                                            (AVRational){1, c->sample_rate},

                                            st->time_base);

        av_log(s, AV_LOG_DEBUG, "pad %d %d\n", mp3->start_pad, mp3->  end_pad);

    }

    /* Misc */

    avio_r8(s->pb);

    /* MP3 gain */

    avio_r8(s->pb);

    /* Preset and surround info */

    avio_rb16(s->pb);

    /* Music length */

    avio_rb32(s->pb);

    /* Music CRC */

    avio_rb16(s->pb);

    /* Info Tag CRC */

    crc = ffio_get_checksum(s->pb);

    v   = avio_rb16(s->pb);

    if (v == crc) {

        ff_replaygain_export_raw(st, r_gain, peak, a_gain, 0);

        av_dict_set(&st->metadata, "encoder", version, 0);

    }

}


int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,

                     int nb_samples, enum AVSampleFormat sample_fmt, int align)

{

    uint8_t *buf;

    int size = av_samples_get_buffer_size(NULL, nb_channels, nb_samples,

                                          sample_fmt, align);

    if (size < 0)

        return size;

    buf = av_mallocz(size);

    if (!buf)

        return AVERROR(ENOMEM);

    size = av_samples_fill_arrays(audio_data, linesize, buf, nb_channels,

                                  nb_samples, sample_fmt, align);

    if (size < 0) {

        av_free(buf);

        return size;

    }

    return 0;

}


static void do_interrupt_protected(int intno, int is_int, int error_code,

                                   unsigned int next_eip, int is_hw)

{

    SegmentCache *dt;

    uint8_t *ptr, *ssp;

    int type, dpl, selector, ss_dpl, cpl, sp_mask;

    int has_error_code, new_stack, shift;

    uint32_t e1, e2, offset, ss, esp, ss_e1, ss_e2;

    uint32_t old_eip;

    has_error_code = 0;

    if (!is_int && !is_hw) {

        switch(intno) {

        case 8:

        case 10:

        case 11:

        case 12:

        case 13:

        case 14:

        case 17:

            has_error_code = 1;

            break;

        }

    }

    dt = &env->idt;

    if (intno * 8 + 7 > dt->limit)

        raise_exception_err(EXCP0D_GPF, intno * 8 + 2);

    ptr = dt->base + intno * 8;

    e1 = ldl_kernel(ptr);

    e2 = ldl_kernel(ptr + 4);

    /* check gate type */

    type = (e2 >> DESC_TYPE_SHIFT) & 0x1f;

    switch(type) {

    case 5: /* task gate */

        /* must do that check here to return the correct error code */

        if (!(e2 & DESC_P_MASK))

            raise_exception_err(EXCP0B_NOSEG, intno * 8 + 2);

        switch_tss(intno * 8, e1, e2, SWITCH_TSS_CALL);

        if (has_error_code) {

            int mask;

            /* push the error code */

            shift = (env->segs[R_CS].flags >> DESC_B_SHIFT) & 1;

            if (env->segs[R_SS].flags & DESC_B_MASK)

                mask = 0xffffffff;

            else

                mask = 0xffff;

            esp = (env->regs[R_ESP] - (2 << shift)) & mask;

            ssp = env->segs[R_SS].base + esp;

            if (shift)

                stl_kernel(ssp, error_code);

            else

                stw_kernel(ssp, error_code);

            env->regs[R_ESP] = (esp & mask) | (env->regs[R_ESP] & ~mask);

        }

        return;

    case 6: /* 286 interrupt gate */

    case 7: /* 286 trap gate */

    case 14: /* 386 interrupt gate */

    case 15: /* 386 trap gate */

        break;

    default:

        raise_exception_err(EXCP0D_GPF, intno * 8 + 2);

        break;

    }

    dpl = (e2 >> DESC_DPL_SHIFT) & 3;

    cpl = env->hflags & HF_CPL_MASK;

    /* check privledge if software int */

    if (is_int && dpl < cpl)

        raise_exception_err(EXCP0D_GPF, intno * 8 + 2);

    /* check valid bit */

    if (!(e2 & DESC_P_MASK))

        raise_exception_err(EXCP0B_NOSEG, intno * 8 + 2);

    selector = e1 >> 16;

    offset = (e2 & 0xffff0000) | (e1 & 0x0000ffff);

    if ((selector & 0xfffc) == 0)

        raise_exception_err(EXCP0D_GPF, 0);

    if (load_segment(&e1, &e2, selector) != 0)

        raise_exception_err(EXCP0D_GPF, selector & 0xfffc);

    if (!(e2 & DESC_S_MASK) || !(e2 & (DESC_CS_MASK)))

        raise_exception_err(EXCP0D_GPF, selector & 0xfffc);

    dpl = (e2 >> DESC_DPL_SHIFT) & 3;

    if (dpl > cpl)

        raise_exception_err(EXCP0D_GPF, selector & 0xfffc);

    if (!(e2 & DESC_P_MASK))

        raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);

    if (!(e2 & DESC_C_MASK) && dpl < cpl) {

        /* to inner priviledge */

        get_ss_esp_from_tss(&ss, &esp, dpl);

        if ((ss & 0xfffc) == 0)

            raise_exception_err(EXCP0A_TSS, ss & 0xfffc);

        if ((ss & 3) != dpl)

            raise_exception_err(EXCP0A_TSS, ss & 0xfffc);

        if (load_segment(&ss_e1, &ss_e2, ss) != 0)

            raise_exception_err(EXCP0A_TSS, ss & 0xfffc);

        ss_dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;

        if (ss_dpl != dpl)

            raise_exception_err(EXCP0A_TSS, ss & 0xfffc);

        if (!(ss_e2 & DESC_S_MASK) ||

            (ss_e2 & DESC_CS_MASK) ||

            !(ss_e2 & DESC_W_MASK))

            raise_exception_err(EXCP0A_TSS, ss & 0xfffc);

        if (!(ss_e2 & DESC_P_MASK))

            raise_exception_err(EXCP0A_TSS, ss & 0xfffc);

        new_stack = 1;

        sp_mask = get_sp_mask(ss_e2);

        ssp = get_seg_base(ss_e1, ss_e2);

    } else if ((e2 & DESC_C_MASK) || dpl == cpl) {

        /* to same priviledge */

        new_stack = 0;

        sp_mask = get_sp_mask(env->segs[R_SS].flags);

        ssp = env->segs[R_SS].base;

        esp = ESP;

    } else {

        raise_exception_err(EXCP0D_GPF, selector & 0xfffc);

        new_stack = 0; /* avoid warning */

        sp_mask = 0; /* avoid warning */

        ssp = NULL; /* avoid warning */

        esp = 0; /* avoid warning */

    }

    shift = type >> 3;

#if 0

    /* XXX: check that enough room is available */

    push_size = 6 + (new_stack << 2) + (has_error_code << 1);

    if (env->eflags & VM_MASK)

        push_size += 8;

    push_size <<= shift;

#endif

    if (is_int)

        old_eip = next_eip;

    else

        old_eip = env->eip;

    if (shift == 1) {

        if (env->eflags & VM_MASK) {

            PUSHL(ssp, esp, sp_mask, env->segs[R_GS].selector);

            PUSHL(ssp, esp, sp_mask, env->segs[R_FS].selector);

            PUSHL(ssp, esp, sp_mask, env->segs[R_DS].selector);

            PUSHL(ssp, esp, sp_mask, env->segs[R_ES].selector);

        }

        if (new_stack) {

            PUSHL(ssp, esp, sp_mask, env->segs[R_SS].selector);

            PUSHL(ssp, esp, sp_mask, ESP);

        }

        PUSHL(ssp, esp, sp_mask, compute_eflags());

        PUSHL(ssp, esp, sp_mask, env->segs[R_CS].selector);

        PUSHL(ssp, esp, sp_mask, old_eip);

        if (has_error_code) {

            PUSHL(ssp, esp, sp_mask, error_code);

        }

    } else {

        if (new_stack) {

            PUSHW(ssp, esp, sp_mask, env->segs[R_SS].selector);

            PUSHW(ssp, esp, sp_mask, ESP);

        }

        PUSHW(ssp, esp, sp_mask, compute_eflags());

        PUSHW(ssp, esp, sp_mask, env->segs[R_CS].selector);

        PUSHW(ssp, esp, sp_mask, old_eip);

        if (has_error_code) {

            PUSHW(ssp, esp, sp_mask, error_code);

        }

    }

    if (new_stack) {

        ss = (ss & ~3) | dpl;

        cpu_x86_load_seg_cache(env, R_SS, ss,

                               ssp, get_seg_limit(ss_e1, ss_e2), ss_e2);

    }

    ESP = (ESP & ~sp_mask) | (esp & sp_mask);

    selector = (selector & ~3) | dpl;

    cpu_x86_load_seg_cache(env, R_CS, selector,

                   get_seg_base(e1, e2),

                   get_seg_limit(e1, e2),

                   e2);

    cpu_x86_set_cpl(env, dpl);

    env->eip = offset;

    /* interrupt gate clear IF mask */

    if ((type & 1) == 0) {

        env->eflags &= ~IF_MASK;

    }

    env->eflags &= ~(TF_MASK | VM_MASK | RF_MASK | NT_MASK);

}


static int v9fs_synth_remove(FsContext *ctx, const char *path)

{

    errno = EPERM;

    return -1;

}


static void dec_b(DisasContext *dc)

{

    if (dc->r0 == R_RA) {

        LOG_DIS("ret\n");

    } else if (dc->r0 == R_EA) {

        LOG_DIS("eret\n");

    } else if (dc->r0 == R_BA) {

        LOG_DIS("bret\n");

    } else {

        LOG_DIS("b r%d\n", dc->r0);

    }

    /* restore IE.IE in case of an eret */

    if (dc->r0 == R_EA) {

        TCGv t0 = tcg_temp_new();

        int l1 = gen_new_label();

        tcg_gen_andi_tl(t0, cpu_ie, IE_EIE);

        tcg_gen_ori_tl(cpu_ie, cpu_ie, IE_IE);

        tcg_gen_brcondi_tl(TCG_COND_EQ, t0, IE_EIE, l1);

        tcg_gen_andi_tl(cpu_ie, cpu_ie, ~IE_IE);

        gen_set_label(l1);

        tcg_temp_free(t0);

    } else if (dc->r0 == R_BA) {

        TCGv t0 = tcg_temp_new();

        int l1 = gen_new_label();

        tcg_gen_andi_tl(t0, cpu_ie, IE_BIE);

        tcg_gen_ori_tl(cpu_ie, cpu_ie, IE_IE);

        tcg_gen_brcondi_tl(TCG_COND_EQ, t0, IE_BIE, l1);

        tcg_gen_andi_tl(cpu_ie, cpu_ie, ~IE_IE);

        gen_set_label(l1);

        tcg_temp_free(t0);

    }

    tcg_gen_mov_tl(cpu_pc, cpu_R[dc->r0]);

    dc->is_jmp = DISAS_JUMP;

}


static void query_facilities(void)

{

    unsigned long hwcap = qemu_getauxval(AT_HWCAP);

    /* Is STORE FACILITY LIST EXTENDED available?  Honestly, I believe this

       is present on all 64-bit systems, but let's check for it anyway.  */

    if (hwcap & HWCAP_S390_STFLE) {

        register int r0 __asm__("0");

        register void *r1 __asm__("1");

        /* stfle 0(%r1) */

        r1 = &facilities;

        asm volatile(".word 0xb2b0,0x1000"

                     : "=r"(r0) : "0"(0), "r"(r1) : "memory", "cc");

    }

}


static void setup_rt_frame(int sig, struct target_sigaction *ka,

                           target_siginfo_t *info,

                           target_sigset_t *set, CPUOpenRISCState *env)

{

    int err = 0;

    abi_ulong frame_addr;

    unsigned long return_ip;

    struct target_rt_sigframe *frame;

    abi_ulong info_addr, uc_addr;

    frame_addr = get_sigframe(ka, env, sizeof(*frame));

    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {

        goto give_sigsegv;

    }

    info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);

    __put_user(info_addr, &frame->pinfo);

    uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);

    __put_user(uc_addr, &frame->puc);

    if (ka->sa_flags & SA_SIGINFO) {

        copy_siginfo_to_user(&frame->info, info);

    }

    /*err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));*/

    __put_user(0, &frame->uc.tuc_flags);

    __put_user(0, &frame->uc.tuc_link);

    __put_user(target_sigaltstack_used.ss_sp,

               &frame->uc.tuc_stack.ss_sp);

    __put_user(sas_ss_flags(env->gpr[1]), &frame->uc.tuc_stack.ss_flags);

    __put_user(target_sigaltstack_used.ss_size,

               &frame->uc.tuc_stack.ss_size);

    err |= setup_sigcontext(&frame->sc, env, set->sig[0]);

    /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/

    if (err) {

        goto give_sigsegv;

    }

    /* trampoline - the desired return ip is the retcode itself */

    return_ip = (unsigned long)&frame->retcode;

    /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */

    __put_user(0xa960, (short *)(frame->retcode + 0));

    __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2));

    __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));

    __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));

    if (err) {

        goto give_sigsegv;

    }

    /* TODO what is the current->exec_domain stuff and invmap ? */

    /* Set up registers for signal handler */

    env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */

    env->gpr[9] = (unsigned long)return_ip;     /* what we enter LATER */

    env->gpr[3] = (unsigned long)sig;           /* arg 1: signo */

    env->gpr[4] = (unsigned long)&frame->info;  /* arg 2: (siginfo_t*) */

    env->gpr[5] = (unsigned long)&frame->uc;    /* arg 3: ucontext */

    /* actually move the usp to reflect the stacked frame */

    env->gpr[1] = (unsigned long)frame;

    return;

give_sigsegv:

    unlock_user_struct(frame, frame_addr, 1);

    if (sig == TARGET_SIGSEGV) {

        ka->_sa_handler = TARGET_SIG_DFL;

    }

    force_sig(TARGET_SIGSEGV);

}


static void imx_enet_do_tx(IMXFECState *s)

{

    int frame_size = 0;

    uint8_t frame[ENET_MAX_FRAME_SIZE];

    uint8_t *ptr = frame;

    uint32_t addr = s->tx_descriptor;

    while (1) {

        IMXENETBufDesc bd;

        int len;

        imx_enet_read_bd(&bd, addr);

        FEC_PRINTF("tx_bd %x flags %04x len %d data %08x option %04x "

                   "status %04x\n", addr, bd.flags, bd.length, bd.data,

                   bd.option, bd.status);

        if ((bd.flags & ENET_BD_R) == 0) {

            /* Run out of descriptors to transmit.  */

            break;

        }

        len = bd.length;

        if (frame_size + len > ENET_MAX_FRAME_SIZE) {

            len = ENET_MAX_FRAME_SIZE - frame_size;

            s->regs[ENET_EIR] |= ENET_INT_BABT;

        }

        dma_memory_read(&address_space_memory, bd.data, ptr, len);

        ptr += len;

        frame_size += len;

        if (bd.flags & ENET_BD_L) {

            if (bd.option & ENET_BD_PINS) {

                struct ip_header *ip_hd = PKT_GET_IP_HDR(frame);

                if (IP_HEADER_VERSION(ip_hd) == 4) {

                    net_checksum_calculate(frame, frame_size);

                }

            }

            if (bd.option & ENET_BD_IINS) {

                struct ip_header *ip_hd = PKT_GET_IP_HDR(frame);

                /* We compute checksum only for IPv4 frames */

                if (IP_HEADER_VERSION(ip_hd) == 4) {

                    uint16_t csum;

                    ip_hd->ip_sum = 0;

                    csum = net_raw_checksum((uint8_t *)ip_hd, sizeof(*ip_hd));

                    ip_hd->ip_sum = cpu_to_be16(csum);

                }

            }

            /* Last buffer in frame.  */

            qemu_send_packet(qemu_get_queue(s->nic), frame, len);

            ptr = frame;

            frame_size = 0;

            if (bd.option & ENET_BD_TX_INT) {

                s->regs[ENET_EIR] |= ENET_INT_TXF;

            }

        }

        if (bd.option & ENET_BD_TX_INT) {

            s->regs[ENET_EIR] |= ENET_INT_TXB;

        }

        bd.flags &= ~ENET_BD_R;

        /* Write back the modified descriptor.  */

        imx_enet_write_bd(&bd, addr);

        /* Advance to the next descriptor.  */

        if ((bd.flags & ENET_BD_W) != 0) {

            addr = s->regs[ENET_TDSR];

        } else {

            addr += sizeof(bd);

        }

    }

    s->tx_descriptor = addr;

    imx_eth_update(s);

}


static uint64_t ne2000_read(void *opaque, target_phys_addr_t addr,

                            unsigned size)

{

    NE2000State *s = opaque;

    if (addr < 0x10 && size == 1) {

        return ne2000_ioport_read(s, addr);

    } else if (addr == 0x10) {

        if (size <= 2) {

            return ne2000_asic_ioport_read(s, addr);

        } else {

            return ne2000_asic_ioport_readl(s, addr);

        }

    } else if (addr == 0x1f && size == 1) {

        return ne2000_reset_ioport_read(s, addr);

    }

    return ((uint64_t)1 << (size * 8)) - 1;

}


static const OptionDef *find_option(const OptionDef *po, const char *name)

{

    const char *p = strchr(name, ':');

    int len = p ? p - name : strlen(name);

    while (po->name != NULL) {

        if (!strncmp(name, po->name, len) && strlen(po->name) == len)

            break;

        po++;

    }

    return po;

}


uint32 float64_to_uint32( float64 a STATUS_PARAM )

{

    int64_t v;

    uint32 res;

    v = float64_to_int64(a STATUS_VAR);

    if (v < 0) {

        res = 0;

        float_raise( float_flag_invalid STATUS_VAR);

    } else if (v > 0xffffffff) {

        res = 0xffffffff;

        float_raise( float_flag_invalid STATUS_VAR);

    } else {

        res = v;

    }

    return res;

}


static void virtio_gpu_handle_cursor(VirtIODevice *vdev, VirtQueue *vq)

{

    VirtIOGPU *g = VIRTIO_GPU(vdev);

    VirtQueueElement elem;

    size_t s;

    struct virtio_gpu_update_cursor cursor_info;

    if (!virtio_queue_ready(vq)) {

        return;

    }

    while (virtqueue_pop(vq, &elem)) {

        s = iov_to_buf(elem.out_sg, elem.out_num, 0,

                       &cursor_info, sizeof(cursor_info));

        if (s != sizeof(cursor_info)) {

            qemu_log_mask(LOG_GUEST_ERROR,

                          "%s: cursor size incorrect %zu vs %zu\n",

                          __func__, s, sizeof(cursor_info));

        } else {

            update_cursor(g, &cursor_info);

        }

        virtqueue_push(vq, &elem, 0);

        virtio_notify(vdev, vq);

    }

}


static int iscsi_truncate(BlockDriverState *bs, int64_t offset)

{

    IscsiLun *iscsilun = bs->opaque;

    Error *local_err = NULL;

    if (iscsilun->type != TYPE_DISK) {

        return -ENOTSUP;

    }

    iscsi_readcapacity_sync(iscsilun, &local_err);

    if (local_err != NULL) {

        error_free(local_err);

        return -EIO;

    }

    if (offset > iscsi_getlength(bs)) {

        return -EINVAL;

    }

    if (iscsilun->allocationmap != NULL) {

        g_free(iscsilun->allocationmap);

        iscsilun->allocationmap = iscsi_allocationmap_init(iscsilun);

    }

    return 0;

}


static void save_native_fp_fxsave(CPUState *env)

{

    struct fpxstate *fp = &fpx1;

    int fptag, i, j;

    uint16_t fpuc;

    asm volatile ("fxsave %0" : : "m" (*fp));

    env->fpuc = fp->fpuc;

    env->fpstt = (fp->fpus >> 11) & 7;

    env->fpus = fp->fpus & ~0x3800;

    fptag = fp->fptag ^ 0xff;

    for(i = 0;i < 8; i++) {

        env->fptags[i] = (fptag >> i) & 1;

    }

    j = env->fpstt;

    for(i = 0;i < 8; i++) {

        memcpy(&env->fpregs[j].d, &fp->fpregs1[i * 16], 10);

        j = (j + 1) & 7;

    }

    if (env->cpuid_features & CPUID_SSE) {

        env->mxcsr = fp->mxcsr;

        memcpy(env->xmm_regs, fp->xmm_regs, CPU_NB_REGS * 16);

    }

    /* we must restore the default rounding state */

    asm volatile ("fninit");

    fpuc = 0x037f | (env->fpuc & (3 << 10));

    asm volatile("fldcw %0" : : "m" (fpuc));

}


static int vmdk_create(const char *filename, QemuOpts *opts, Error **errp)

{

    int idx = 0;

    BlockDriverState *new_bs = NULL;

    Error *local_err = NULL;

    char *desc = NULL;

    int64_t total_size = 0, filesize;

    char *adapter_type = NULL;

    char *backing_file = NULL;

    char *fmt = NULL;

    int flags = 0;

    int ret = 0;

    bool flat, split, compress;

    GString *ext_desc_lines;

    char path[PATH_MAX], prefix[PATH_MAX], postfix[PATH_MAX];

    const int64_t split_size = 0x80000000;  /* VMDK has constant split size */

    const char *desc_extent_line;

    char parent_desc_line[BUF_SIZE] = "";

    uint32_t parent_cid = 0xffffffff;

    uint32_t number_heads = 16;

    bool zeroed_grain = false;

    uint32_t desc_offset = 0, desc_len;

    const char desc_template[] =

        "# Disk DescriptorFile\n"

        "version=1\n"

        "CID=%" PRIx32 "\n"

        "parentCID=%" PRIx32 "\n"

        "createType=\"%s\"\n"

        "%s"

        "\n"

        "# Extent description\n"

        "%s"

        "\n"

        "# The Disk Data Base\n"

        "#DDB\n"

        "\n"

        "ddb.virtualHWVersion = \"%d\"\n"

        "ddb.geometry.cylinders = \"%" PRId64 "\"\n"

        "ddb.geometry.heads = \"%" PRIu32 "\"\n"

        "ddb.geometry.sectors = \"63\"\n"

        "ddb.adapterType = \"%s\"\n";

    ext_desc_lines = g_string_new(NULL);

    if (filename_decompose(filename, path, prefix, postfix, PATH_MAX, errp)) {

        ret = -EINVAL;

        goto exit;

    }

    /* Read out options */

    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),

                          BDRV_SECTOR_SIZE);

    adapter_type = qemu_opt_get_del(opts, BLOCK_OPT_ADAPTER_TYPE);

    backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);

    if (qemu_opt_get_bool_del(opts, BLOCK_OPT_COMPAT6, false)) {

        flags |= BLOCK_FLAG_COMPAT6;

    }

    fmt = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT);

    if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ZEROED_GRAIN, false)) {

        zeroed_grain = true;

    }

    if (!adapter_type) {

        adapter_type = g_strdup("ide");

    } else if (strcmp(adapter_type, "ide") &&

               strcmp(adapter_type, "buslogic") &&

               strcmp(adapter_type, "lsilogic") &&

               strcmp(adapter_type, "legacyESX")) {

        error_setg(errp, "Unknown adapter type: '%s'", adapter_type);

        ret = -EINVAL;

        goto exit;

    }

    if (strcmp(adapter_type, "ide") != 0) {

        /* that's the number of heads with which vmware operates when

           creating, exporting, etc. vmdk files with a non-ide adapter type */

        number_heads = 255;

    }

    if (!fmt) {

        /* Default format to monolithicSparse */

        fmt = g_strdup("monolithicSparse");

    } else if (strcmp(fmt, "monolithicFlat") &&

               strcmp(fmt, "monolithicSparse") &&

               strcmp(fmt, "twoGbMaxExtentSparse") &&

               strcmp(fmt, "twoGbMaxExtentFlat") &&

               strcmp(fmt, "streamOptimized")) {

        error_setg(errp, "Unknown subformat: '%s'", fmt);

        ret = -EINVAL;

        goto exit;

    }

    split = !(strcmp(fmt, "twoGbMaxExtentFlat") &&

              strcmp(fmt, "twoGbMaxExtentSparse"));

    flat = !(strcmp(fmt, "monolithicFlat") &&

             strcmp(fmt, "twoGbMaxExtentFlat"));

    compress = !strcmp(fmt, "streamOptimized");

    if (flat) {

        desc_extent_line = "RW %" PRId64 " FLAT \"%s\" 0\n";

    } else {

        desc_extent_line = "RW %" PRId64 " SPARSE \"%s\"\n";

    }

    if (flat && backing_file) {

        error_setg(errp, "Flat image can't have backing file");

        ret = -ENOTSUP;

        goto exit;

    }

    if (flat && zeroed_grain) {

        error_setg(errp, "Flat image can't enable zeroed grain");

        ret = -ENOTSUP;

        goto exit;

    }

    if (backing_file) {

        BlockDriverState *bs = NULL;

        ret = bdrv_open(&bs, backing_file, NULL, NULL, BDRV_O_NO_BACKING, NULL,

                        errp);

        if (ret != 0) {

            goto exit;

        }

        if (strcmp(bs->drv->format_name, "vmdk")) {

            bdrv_unref(bs);

            ret = -EINVAL;

            goto exit;

        }

        parent_cid = vmdk_read_cid(bs, 0);

        bdrv_unref(bs);

        snprintf(parent_desc_line, sizeof(parent_desc_line),

                "parentFileNameHint=\"%s\"", backing_file);

    }

    /* Create extents */

    filesize = total_size;

    while (filesize > 0) {

        char desc_line[BUF_SIZE];

        char ext_filename[PATH_MAX];

        char desc_filename[PATH_MAX];

        int64_t size = filesize;

        if (split && size > split_size) {

            size = split_size;

        }

        if (split) {

            snprintf(desc_filename, sizeof(desc_filename), "%s-%c%03d%s",

                    prefix, flat ? 'f' : 's', ++idx, postfix);

        } else if (flat) {

            snprintf(desc_filename, sizeof(desc_filename), "%s-flat%s",

                    prefix, postfix);

        } else {

            snprintf(desc_filename, sizeof(desc_filename), "%s%s",

                    prefix, postfix);

        }

        snprintf(ext_filename, sizeof(ext_filename), "%s%s",

                path, desc_filename);

        if (vmdk_create_extent(ext_filename, size,

                               flat, compress, zeroed_grain, opts, errp)) {

            ret = -EINVAL;

            goto exit;

        }

        filesize -= size;

        /* Format description line */

        snprintf(desc_line, sizeof(desc_line),

                    desc_extent_line, size / BDRV_SECTOR_SIZE, desc_filename);

        g_string_append(ext_desc_lines, desc_line);

    }

    /* generate descriptor file */

    desc = g_strdup_printf(desc_template,

                           g_random_int(),

                           parent_cid,

                           fmt,

                           parent_desc_line,

                           ext_desc_lines->str,

                           (flags & BLOCK_FLAG_COMPAT6 ? 6 : 4),

                           total_size /

                               (int64_t)(63 * number_heads * BDRV_SECTOR_SIZE),

                           number_heads,

                           adapter_type);

    desc_len = strlen(desc);

    /* the descriptor offset = 0x200 */

    if (!split && !flat) {

        desc_offset = 0x200;

    } else {

        ret = bdrv_create_file(filename, opts, &local_err);

        if (ret < 0) {

            error_propagate(errp, local_err);

            goto exit;

        }

    }

    assert(new_bs == NULL);

    ret = bdrv_open(&new_bs, filename, NULL, NULL,

                    BDRV_O_RDWR | BDRV_O_PROTOCOL, NULL, &local_err);

    if (ret < 0) {

        error_propagate(errp, local_err);

        goto exit;

    }

    ret = bdrv_pwrite(new_bs, desc_offset, desc, desc_len);

    if (ret < 0) {

        error_setg_errno(errp, -ret, "Could not write description");

        goto exit;

    }

    /* bdrv_pwrite write padding zeros to align to sector, we don't need that

     * for description file */

    if (desc_offset == 0) {

        ret = bdrv_truncate(new_bs, desc_len);

        if (ret < 0) {

            error_setg_errno(errp, -ret, "Could not truncate file");

        }

    }

exit:

    if (new_bs) {

        bdrv_unref(new_bs);

    }

    g_free(adapter_type);

    g_free(backing_file);

    g_free(fmt);

    g_free(desc);

    g_string_free(ext_desc_lines, true);

    return ret;

}


void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,

                             int64_t cur_sector, int64_t nr_sectors)

{

    assert(bdrv_dirty_bitmap_enabled(bitmap));

    hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);

}


static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)

{

    av_freep(dst);

    *dst = av_strdup(val);

    return 0;

}


static int mkv_write_native_codecprivate(AVFormatContext *s,

                                         AVCodecParameters *par,

                                         AVIOContext *dyn_cp)

{

    switch (par->codec_id) {

    case AV_CODEC_ID_VORBIS:

    case AV_CODEC_ID_THEORA:

        return put_xiph_codecpriv(s, dyn_cp, par);

    case AV_CODEC_ID_FLAC:

        return put_flac_codecpriv(s, dyn_cp, par);

    case AV_CODEC_ID_WAVPACK:

        return put_wv_codecpriv(dyn_cp, par);

    case AV_CODEC_ID_H264:

        return ff_isom_write_avcc(dyn_cp, par->extradata,

                                  par->extradata_size);

    case AV_CODEC_ID_HEVC:

        ff_isom_write_hvcc(dyn_cp, par->extradata,

                           par->extradata_size, 0);

        return 0;

    case AV_CODEC_ID_ALAC:

        if (par->extradata_size < 36) {

            av_log(s, AV_LOG_ERROR,

                   "Invalid extradata found, ALAC expects a 36-byte "

                   "QuickTime atom.");

            return AVERROR_INVALIDDATA;

        } else

            avio_write(dyn_cp, par->extradata + 12,

                       par->extradata_size - 12);

        break;

    default:

        if (par->codec_id == AV_CODEC_ID_PRORES &&

            ff_codec_get_id(ff_codec_movvideo_tags, par->codec_tag) == AV_CODEC_ID_PRORES) {

            avio_wl32(dyn_cp, par->codec_tag);

        } else if (par->extradata_size && par->codec_id != AV_CODEC_ID_TTA)

            avio_write(dyn_cp, par->extradata, par->extradata_size);

    }

    return 0;

}


static void set_cfg_value(bool is_max, int index, int value)

{

    if (is_max) {

        cfg.buckets[index].max = value;

    } else {

        cfg.buckets[index].avg = value;

    }

}


static int coroutine_fn mirror_iteration(MirrorBlockJob *s)

{

    BlockDriverState *source = s->common.bs;

    BlockDriverState *target = s->target;

    QEMUIOVector qiov;

    int ret, nb_sectors;

    int64_t end;

    struct iovec iov;

    end = s->common.len >> BDRV_SECTOR_BITS;

    s->sector_num = bdrv_get_next_dirty(source, s->sector_num);

    nb_sectors = MIN(BDRV_SECTORS_PER_DIRTY_CHUNK, end - s->sector_num);

    bdrv_reset_dirty(source, s->sector_num, nb_sectors);

    /* Copy the dirty cluster.  */

    iov.iov_base = s->buf;

    iov.iov_len  = nb_sectors * 512;

    qemu_iovec_init_external(&qiov, &iov, 1);

    trace_mirror_one_iteration(s, s->sector_num, nb_sectors);

    ret = bdrv_co_readv(source, s->sector_num, nb_sectors, &qiov);

    if (ret < 0) {

        return ret;

    }

    return bdrv_co_writev(target, s->sector_num, nb_sectors, &qiov);

}


static void decode_rr_divide(CPUTriCoreState *env, DisasContext *ctx)

{

    uint32_t op2;

    int r1, r2, r3;

    TCGv temp, temp2;

    op2 = MASK_OP_RR_OP2(ctx->opcode);

    r3 = MASK_OP_RR_D(ctx->opcode);

    r2 = MASK_OP_RR_S2(ctx->opcode);

    r1 = MASK_OP_RR_S1(ctx->opcode);

    switch (op2) {

    case OPC2_32_RR_BMERGE:

        gen_helper_bmerge(cpu_gpr_d[r3], cpu_gpr_d[r1], cpu_gpr_d[r2]);

        break;

    case OPC2_32_RR_BSPLIT:

        gen_bsplit(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1]);

        break;

    case OPC2_32_RR_DVINIT_B:

        gen_dvinit_b(env, cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],

                     cpu_gpr_d[r2]);

        break;

    case OPC2_32_RR_DVINIT_BU:

        temp = tcg_temp_new();

        temp2 = tcg_temp_new();

        /* reset av */

        tcg_gen_movi_tl(cpu_PSW_AV, 0);

        if (!tricore_feature(env, TRICORE_FEATURE_131)) {

            /* overflow = (abs(D[r3+1]) >= abs(D[r2])) */

            tcg_gen_neg_tl(temp, cpu_gpr_d[r3+1]);

            /* use cpu_PSW_AV to compare against 0 */

            tcg_gen_movcond_tl(TCG_COND_LT, temp, cpu_gpr_d[r3+1], cpu_PSW_AV,

                               temp, cpu_gpr_d[r3+1]);

            tcg_gen_neg_tl(temp2, cpu_gpr_d[r2]);

            tcg_gen_movcond_tl(TCG_COND_LT, temp2, cpu_gpr_d[r2], cpu_PSW_AV,

                               temp2, cpu_gpr_d[r2]);

            tcg_gen_setcond_tl(TCG_COND_GE, cpu_PSW_V, temp, temp2);

        } else {

            /* overflow = (D[b] == 0) */

            tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);

        }

        tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);

        /* sv */

        tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);

        /* write result */

        tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 8);

        tcg_gen_shli_tl(cpu_gpr_d[r3], cpu_gpr_d[r1], 24);

        tcg_gen_mov_tl(cpu_gpr_d[r3+1], temp);

        tcg_temp_free(temp);

        tcg_temp_free(temp2);

        break;

    case OPC2_32_RR_DVINIT_H:

        gen_dvinit_h(env, cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1],

                     cpu_gpr_d[r2]);

        break;

    case OPC2_32_RR_DVINIT_HU:

        temp = tcg_temp_new();

        temp2 = tcg_temp_new();

        /* reset av */

        tcg_gen_movi_tl(cpu_PSW_AV, 0);

        if (!tricore_feature(env, TRICORE_FEATURE_131)) {

            /* overflow = (abs(D[r3+1]) >= abs(D[r2])) */

            tcg_gen_neg_tl(temp, cpu_gpr_d[r3+1]);

            /* use cpu_PSW_AV to compare against 0 */

            tcg_gen_movcond_tl(TCG_COND_LT, temp, cpu_gpr_d[r3+1], cpu_PSW_AV,

                               temp, cpu_gpr_d[r3+1]);

            tcg_gen_neg_tl(temp2, cpu_gpr_d[r2]);

            tcg_gen_movcond_tl(TCG_COND_LT, temp2, cpu_gpr_d[r2], cpu_PSW_AV,

                               temp2, cpu_gpr_d[r2]);

            tcg_gen_setcond_tl(TCG_COND_GE, cpu_PSW_V, temp, temp2);

        } else {

            /* overflow = (D[b] == 0) */

            tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);

        }

        tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);

        /* sv */

        tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);

        /* write result */

        tcg_gen_mov_tl(temp, cpu_gpr_d[r1]);

        tcg_gen_shri_tl(cpu_gpr_d[r3+1], temp, 16);

        tcg_gen_shli_tl(cpu_gpr_d[r3], temp, 16);

        tcg_temp_free(temp);

        tcg_temp_free(temp2);

        break;

    case OPC2_32_RR_DVINIT:

        temp = tcg_temp_new();

        temp2 = tcg_temp_new();

        /* overflow = ((D[b] == 0) ||

                      ((D[b] == 0xFFFFFFFF) && (D[a] == 0x80000000))) */

        tcg_gen_setcondi_tl(TCG_COND_EQ, temp, cpu_gpr_d[r2], 0xffffffff);

        tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, cpu_gpr_d[r1], 0x80000000);

        tcg_gen_and_tl(temp, temp, temp2);

        tcg_gen_setcondi_tl(TCG_COND_EQ, temp2, cpu_gpr_d[r2], 0);

        tcg_gen_or_tl(cpu_PSW_V, temp, temp2);

        tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);

        /* sv */

        tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);

        /* reset av */

       tcg_gen_movi_tl(cpu_PSW_AV, 0);

        /* write result */

        tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);

        /* sign extend to high reg */

        tcg_gen_sari_tl(cpu_gpr_d[r3+1], cpu_gpr_d[r1], 31);

        tcg_temp_free(temp);

        tcg_temp_free(temp2);

        break;

    case OPC2_32_RR_DVINIT_U:

        /* overflow = (D[b] == 0) */

        tcg_gen_setcondi_tl(TCG_COND_EQ, cpu_PSW_V, cpu_gpr_d[r2], 0);

        tcg_gen_shli_tl(cpu_PSW_V, cpu_PSW_V, 31);

        /* sv */

        tcg_gen_or_tl(cpu_PSW_SV, cpu_PSW_SV, cpu_PSW_V);

        /* reset av */

        tcg_gen_movi_tl(cpu_PSW_AV, 0);

        /* write result */

        tcg_gen_mov_tl(cpu_gpr_d[r3], cpu_gpr_d[r1]);

        /* zero extend to high reg*/

        tcg_gen_movi_tl(cpu_gpr_d[r3+1], 0);

        break;

    case OPC2_32_RR_PARITY:

        gen_helper_parity(cpu_gpr_d[r3], cpu_gpr_d[r1]);

        break;

    case OPC2_32_RR_UNPACK:

        gen_unpack(cpu_gpr_d[r3], cpu_gpr_d[r3+1], cpu_gpr_d[r1]);

        break;

    }

}


static int local_unlinkat(FsContext *ctx, V9fsPath *dir,

                          const char *name, int flags)

{

    int ret;

    V9fsString fullname;

    char *buffer;

    v9fs_string_init(&fullname);

    v9fs_string_sprintf(&fullname, "%s/%s", dir->data, name);

    if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {

        if (flags == AT_REMOVEDIR) {

            /*

             * If directory remove .virtfs_metadata contained in the

             * directory

             */

            buffer = g_strdup_printf("%s/%s/%s", ctx->fs_root,

                                     fullname.data, VIRTFS_META_DIR);

            ret = remove(buffer);

            g_free(buffer);

            if (ret < 0 && errno != ENOENT) {

                /*

                 * We didn't had the .virtfs_metadata file. May be file created

                 * in non-mapped mode ?. Ignore ENOENT.

                 */

                goto err_out;

            }

        }

        /*

         * Now remove the name from parent directory

         * .virtfs_metadata directory.

         */

        buffer = local_mapped_attr_path(ctx, fullname.data);

        ret = remove(buffer);

        g_free(buffer);

        if (ret < 0 && errno != ENOENT) {

            /*

             * We didn't had the .virtfs_metadata file. May be file created

             * in non-mapped mode ?. Ignore ENOENT.

             */

            goto err_out;

        }

    }

    /* Remove the name finally */

    buffer = rpath(ctx, fullname.data);

    ret = remove(buffer);

    g_free(buffer);

err_out:

    v9fs_string_free(&fullname);

    return ret;

}


static uint64_t pl011_read(void *opaque, hwaddr offset,

                           unsigned size)

{

    PL011State *s = (PL011State *)opaque;

    uint32_t c;

    if (offset >= 0xfe0 && offset < 0x1000) {

        return s->id[(offset - 0xfe0) >> 2];

    }

    switch (offset >> 2) {

    case 0: /* UARTDR */

        s->flags &= ~PL011_FLAG_RXFF;

        c = s->read_fifo[s->read_pos];

        if (s->read_count > 0) {

            s->read_count--;

            if (++s->read_pos == 16)

                s->read_pos = 0;

        }

        if (s->read_count == 0) {

            s->flags |= PL011_FLAG_RXFE;

        }

        if (s->read_count == s->read_trigger - 1)

            s->int_level &= ~ PL011_INT_RX;

        pl011_update(s);

        if (s->chr) {

            qemu_chr_accept_input(s->chr);

        }

        return c;

    case 1: /* UARTCR */

        return 0;

    case 6: /* UARTFR */

        return s->flags;

    case 8: /* UARTILPR */

        return s->ilpr;

    case 9: /* UARTIBRD */

        return s->ibrd;

    case 10: /* UARTFBRD */

        return s->fbrd;

    case 11: /* UARTLCR_H */

        return s->lcr;

    case 12: /* UARTCR */

        return s->cr;

    case 13: /* UARTIFLS */

        return s->ifl;

    case 14: /* UARTIMSC */

        return s->int_enabled;

    case 15: /* UARTRIS */

        return s->int_level;

    case 16: /* UARTMIS */

        return s->int_level & s->int_enabled;

    case 18: /* UARTDMACR */

        return s->dmacr;

    default:

        qemu_log_mask(LOG_GUEST_ERROR,

                      "pl011_read: Bad offset %x\n", (int)offset);

        return 0;

    }

}


static BlockAIOCB *inject_error(BlockDriverState *bs,

    BlockCompletionFunc *cb, void *opaque, BlkdebugRule *rule)

{

    BDRVBlkdebugState *s = bs->opaque;

    int error = rule->options.inject.error;

    struct BlkdebugAIOCB *acb;

    QEMUBH *bh;

    if (rule->options.inject.once) {

        QSIMPLEQ_INIT(&s->active_rules);

    }

    if (rule->options.inject.immediately) {

        return NULL;

    }

    acb = qemu_aio_get(&blkdebug_aiocb_info, bs, cb, opaque);

    acb->ret = -error;

    bh = aio_bh_new(bdrv_get_aio_context(bs), error_callback_bh, acb);

    acb->bh = bh;

    qemu_bh_schedule(bh);

    return &acb->common;

}


static void colo_old_packet_check_one_conn(void *opaque,

                                           void *user_data)

{

    Connection *conn = opaque;

    GList *result = NULL;

    int64_t check_time = REGULAR_PACKET_CHECK_MS;

    result = g_queue_find_custom(&conn->primary_list,

                                 &check_time,

                                 (GCompareFunc)colo_old_packet_check_one);

    if (result) {

        /* do checkpoint will flush old packet */

        /* TODO: colo_notify_checkpoint();*/

    }

}


int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot)

{

    int fd;

    int64_t size;

    struct cow_header_v2 cow_header;

#ifndef _WIN32

    char template[] = "/tmp/vl.XXXXXX";

    int cow_fd;

    struct stat st;

#endif

    bs->read_only = 0;

    bs->fd = -1;

    bs->cow_fd = -1;

    bs->cow_bitmap = NULL;

    strcpy(bs->filename, filename);

    /* open standard HD image */

#ifdef _WIN32

    fd = open(filename, O_RDWR | O_BINARY);

#else

    fd = open(filename, O_RDWR | O_LARGEFILE);

#endif

    if (fd < 0) {

        /* read only image on disk */

#ifdef _WIN32

        fd = open(filename, O_RDONLY | O_BINARY);

#else

        fd = open(filename, O_RDONLY | O_LARGEFILE);

#endif

        if (fd < 0) {

            perror(filename);

            goto fail;

        }

        if (!snapshot)

            bs->read_only = 1;

    }

    bs->fd = fd;

    /* see if it is a cow image */

    if (read(fd, &cow_header, sizeof(cow_header)) != sizeof(cow_header)) {

        fprintf(stderr, "%s: could not read header\n", filename);

        goto fail;

    }

#ifndef _WIN32

    if (be32_to_cpu(cow_header.magic) == COW_MAGIC &&

        be32_to_cpu(cow_header.version) == COW_VERSION) {

        /* cow image found */

        size = cow_header.size;

#ifndef WORDS_BIGENDIAN

        size = bswap64(size);

#endif

        bs->total_sectors = size / 512;

        bs->cow_fd = fd;

        bs->fd = -1;

        if (cow_header.backing_file[0] != '\0') {

            if (stat(cow_header.backing_file, &st) != 0) {

                fprintf(stderr, "%s: could not find original disk image '%s'\n", filename, cow_header.backing_file);

                goto fail;

            }

            if (st.st_mtime != be32_to_cpu(cow_header.mtime)) {

                fprintf(stderr, "%s: original raw disk image '%s' does not match saved timestamp\n", filename, cow_header.backing_file);

                goto fail;

            }

            fd = open(cow_header.backing_file, O_RDONLY | O_LARGEFILE);

            if (fd < 0)

                goto fail;

            bs->fd = fd;

        }

        /* mmap the bitmap */

        bs->cow_bitmap_size = ((bs->total_sectors + 7) >> 3) + sizeof(cow_header);

        bs->cow_bitmap_addr = mmap(get_mmap_addr(bs->cow_bitmap_size),

                                   bs->cow_bitmap_size,

                                   PROT_READ | PROT_WRITE,

                                   MAP_SHARED, bs->cow_fd, 0);

        if (bs->cow_bitmap_addr == MAP_FAILED)

            goto fail;

        bs->cow_bitmap = bs->cow_bitmap_addr + sizeof(cow_header);

        bs->cow_sectors_offset = (bs->cow_bitmap_size + 511) & ~511;

        snapshot = 0;

    } else

#endif

    {

        /* standard raw image */

        size = lseek64(fd, 0, SEEK_END);

        bs->total_sectors = size / 512;

        bs->fd = fd;

    }

#ifndef _WIN32

    if (snapshot) {

        /* create a temporary COW file */

        cow_fd = mkstemp64(template);

        if (cow_fd < 0)

            goto fail;

        bs->cow_fd = cow_fd;

	unlink(template);

        /* just need to allocate bitmap */

        bs->cow_bitmap_size = (bs->total_sectors + 7) >> 3;

        bs->cow_bitmap_addr = mmap(get_mmap_addr(bs->cow_bitmap_size),

                                   bs->cow_bitmap_size,

                                   PROT_READ | PROT_WRITE,

                                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

        if (bs->cow_bitmap_addr == MAP_FAILED)

            goto fail;

        bs->cow_bitmap = bs->cow_bitmap_addr;

        bs->cow_sectors_offset = 0;

    }

#endif

    bs->inserted = 1;

    /* call the change callback */

    if (bs->change_cb)

        bs->change_cb(bs->change_opaque);

    return 0;

 fail:

    bdrv_close(bs);

    return -1;

}


static void ehci_detach(USBPort *port)

{

    EHCIState *s = port->opaque;

    uint32_t *portsc = &s->portsc[port->index];

    const char *owner = (*portsc & PORTSC_POWNER) ? "comp" : "ehci";

    trace_usb_ehci_port_detach(port->index, owner);

    if (*portsc & PORTSC_POWNER) {

        USBPort *companion = s->companion_ports[port->index];

        companion->ops->detach(companion);

        companion->dev = NULL;

        /*

         * EHCI spec 4.2.2: "When a disconnect occurs... On the event,

         * the port ownership is returned immediately to the EHCI controller."

         */

        *portsc &= ~PORTSC_POWNER;

        return;

    }

    ehci_queues_rip_device(s, port->dev, 0);

    ehci_queues_rip_device(s, port->dev, 1);

    *portsc &= ~(PORTSC_CONNECT|PORTSC_PED);

    *portsc |= PORTSC_CSC;

    ehci_raise_irq(s, USBSTS_PCD);

}


static inline void RENAME(rgb32to15)(const uint8_t *src, uint8_t *dst, long src_size)

{

	const uint8_t *s = src;

	const uint8_t *end;

#ifdef HAVE_MMX

	const uint8_t *mm_end;

#endif

	uint16_t *d = (uint16_t *)dst;

	end = s + src_size;

#ifdef HAVE_MMX

	mm_end = end - 15;

#if 1 //is faster only if multiplies are reasonable fast (FIXME figure out on which cpus this is faster, on Athlon its slightly faster)

	asm volatile(

		"movq %3, %%mm5			\n\t"

		"movq %4, %%mm6			\n\t"

		"movq %5, %%mm7			\n\t"

		"jmp 2f				\n\t"

		ASMALIGN(4)

		"1:				\n\t"

		PREFETCH" 32(%1)		\n\t"

		"movd	(%1), %%mm0		\n\t"

		"movd	4(%1), %%mm3		\n\t"

		"punpckldq 8(%1), %%mm0		\n\t"

		"punpckldq 12(%1), %%mm3	\n\t"

		"movq %%mm0, %%mm1		\n\t"

		"movq %%mm3, %%mm4		\n\t"

		"pand %%mm6, %%mm0		\n\t"

		"pand %%mm6, %%mm3		\n\t"

		"pmaddwd %%mm7, %%mm0		\n\t"

		"pmaddwd %%mm7, %%mm3		\n\t"

		"pand %%mm5, %%mm1		\n\t"

		"pand %%mm5, %%mm4		\n\t"

		"por %%mm1, %%mm0		\n\t"

		"por %%mm4, %%mm3		\n\t"

		"psrld $6, %%mm0		\n\t"

		"pslld $10, %%mm3		\n\t"

		"por %%mm3, %%mm0		\n\t"

		MOVNTQ"	%%mm0, (%0)		\n\t"

		"add $16, %1			\n\t"

		"add $8, %0			\n\t"

		"2:				\n\t"

		"cmp %2, %1			\n\t"

		" jb 1b				\n\t"

		: "+r" (d), "+r"(s)

		: "r" (mm_end), "m" (mask3215g), "m" (mask3216br), "m" (mul3215)

	);

#else

	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

	__asm __volatile(

	    "movq	%0, %%mm7\n\t"

	    "movq	%1, %%mm6\n\t"

	    ::"m"(red_15mask),"m"(green_15mask));

	while(s < mm_end)

	{

	    __asm __volatile(

		PREFETCH" 32%1\n\t"

		"movd	%1, %%mm0\n\t"

		"movd	4%1, %%mm3\n\t"

		"punpckldq 8%1, %%mm0\n\t"

		"punpckldq 12%1, %%mm3\n\t"

		"movq	%%mm0, %%mm1\n\t"

		"movq	%%mm0, %%mm2\n\t"

		"movq	%%mm3, %%mm4\n\t"

		"movq	%%mm3, %%mm5\n\t"

		"psrlq	$3, %%mm0\n\t"

		"psrlq	$3, %%mm3\n\t"

		"pand	%2, %%mm0\n\t"

		"pand	%2, %%mm3\n\t"

		"psrlq	$6, %%mm1\n\t"

		"psrlq	$6, %%mm4\n\t"

		"pand	%%mm6, %%mm1\n\t"

		"pand	%%mm6, %%mm4\n\t"

		"psrlq	$9, %%mm2\n\t"

		"psrlq	$9, %%mm5\n\t"

		"pand	%%mm7, %%mm2\n\t"

		"pand	%%mm7, %%mm5\n\t"

		"por	%%mm1, %%mm0\n\t"

		"por	%%mm4, %%mm3\n\t"

		"por	%%mm2, %%mm0\n\t"

		"por	%%mm5, %%mm3\n\t"

		"psllq	$16, %%mm3\n\t"

		"por	%%mm3, %%mm0\n\t"

		MOVNTQ"	%%mm0, %0\n\t"

		:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");

		d += 4;

		s += 16;

	}

#endif

	__asm __volatile(SFENCE:::"memory");

	__asm __volatile(EMMS:::"memory");

#endif

	while(s < end)

	{

		register int rgb = *(uint32_t*)s; s += 4;

		*d++ = ((rgb&0xFF)>>3) + ((rgb&0xF800)>>6) + ((rgb&0xF80000)>>9);

	}

}


PPC_OP(tlbie)

{

    do_tlbie();

    RETURN();

}


static int avs_probe(AVProbeData * p)

{

    const uint8_t *d;

    if (p->buf_size < 2)

        return 0;

    d = p->buf;

    if (d[0] == 'w' && d[1] == 'W' && d[2] == 0x10 && d[3] == 0)

        return 50;

    return 0;

}


static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,

                        AVPacket *avpkt) {

    const uint8_t *buf = avpkt->data;

    int buf_size = avpkt->size;

    NuvContext *c = avctx->priv_data;

    AVFrame *picture = data;

    int orig_size = buf_size;

    int keyframe;

    int result;

    enum {NUV_UNCOMPRESSED = '0', NUV_RTJPEG = '1',

          NUV_RTJPEG_IN_LZO = '2', NUV_LZO = '3',

          NUV_BLACK = 'N', NUV_COPY_LAST = 'L'} comptype;

    if (buf_size < 12) {

        av_log(avctx, AV_LOG_ERROR, "coded frame too small\n");

        return -1;

    }

    // codec data (rtjpeg quant tables)

    if (buf[0] == 'D' && buf[1] == 'R') {

        int ret;

        // skip rest of the frameheader.

        buf = &buf[12];

        buf_size -= 12;

        ret = get_quant(avctx, c, buf, buf_size);

        if (ret < 0)

            return ret;

        ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->height, c->lq, c->cq);

        return orig_size;

    }

    if (buf[0] != 'V' || buf_size < 12) {

        av_log(avctx, AV_LOG_ERROR, "not a nuv video frame\n");

        return -1;

    }

    comptype = buf[1];

    switch (comptype) {

        case NUV_RTJPEG_IN_LZO:

        case NUV_RTJPEG:

            keyframe = !buf[2]; break;

        case NUV_COPY_LAST:

            keyframe = 0; break;

        default:

            keyframe = 1; break;

    }

    // skip rest of the frameheader.

    buf = &buf[12];

    buf_size -= 12;

    if (comptype == NUV_RTJPEG_IN_LZO || comptype == NUV_LZO) {

        int outlen = c->decomp_size, inlen = buf_size;

        if (av_lzo1x_decode(c->decomp_buf, &outlen, buf, &inlen))

            av_log(avctx, AV_LOG_ERROR, "error during lzo decompression\n");

        buf = c->decomp_buf;

        buf_size = c->decomp_size;

    }

    if (c->codec_frameheader) {

        int w, h, q;

        if (buf_size < 12) {

            av_log(avctx, AV_LOG_ERROR, "invalid nuv video frame\n");

            return -1;

        }

        w = AV_RL16(&buf[6]);

        h = AV_RL16(&buf[8]);

        q = buf[10];

        if (!codec_reinit(avctx, w, h, q))

            return -1;

        buf = &buf[12];

        buf_size -= 12;

    }

    if (keyframe && c->pic.data[0])

        avctx->release_buffer(avctx, &c->pic);

    c->pic.reference = 3;

    c->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE |

                          FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;

    result = avctx->reget_buffer(avctx, &c->pic);

    if (result < 0) {

        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

        return -1;

    }

    c->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

    c->pic.key_frame = keyframe;

    // decompress/copy/whatever data

    switch (comptype) {

        case NUV_LZO:

        case NUV_UNCOMPRESSED: {

            int height = c->height;

            if (buf_size < c->width * height * 3 / 2) {

                av_log(avctx, AV_LOG_ERROR, "uncompressed frame too short\n");

                height = buf_size / c->width / 3 * 2;

            }

            copy_frame(&c->pic, buf, c->width, height);

            break;

        }

        case NUV_RTJPEG_IN_LZO:

        case NUV_RTJPEG: {

            ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, buf, buf_size);

            break;

        }

        case NUV_BLACK: {

            memset(c->pic.data[0], 0, c->width * c->height);

            memset(c->pic.data[1], 128, c->width * c->height / 4);

            memset(c->pic.data[2], 128, c->width * c->height / 4);

            break;

        }

        case NUV_COPY_LAST: {

            /* nothing more to do here */

            break;

        }

        default:

            av_log(avctx, AV_LOG_ERROR, "unknown compression\n");

            return -1;

    }

    *picture = c->pic;

    *data_size = sizeof(AVFrame);

    return orig_size;

}


qio_channel_websock_extract_headers(char *buffer,

                                    QIOChannelWebsockHTTPHeader *hdrs,

                                    size_t nhdrsalloc,

                                    Error **errp)

{

    char *nl, *sep, *tmp;

    size_t nhdrs = 0;

    /*

     * First parse the HTTP protocol greeting of format:

     *

     *   $METHOD $PATH $VERSION

     *

     * e.g.

     *

     *   GET / HTTP/1.1

     */

    nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);

    if (!nl) {

        error_setg(errp, "Missing HTTP header delimiter");

        return 0;

    }

    *nl = '\0';

    tmp = strchr(buffer, ' ');

    if (!tmp) {

        error_setg(errp, "Missing HTTP path delimiter");

        return 0;

    }

    *tmp = '\0';

    if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_METHOD)) {

        error_setg(errp, "Unsupported HTTP method %s", buffer);

        return 0;

    }

    buffer = tmp + 1;

    tmp = strchr(buffer, ' ');

    if (!tmp) {

        error_setg(errp, "Missing HTTP version delimiter");

        return 0;

    }

    *tmp = '\0';

    if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_PATH)) {

        error_setg(errp, "Unexpected HTTP path %s", buffer);

        return 0;

    }

    buffer = tmp + 1;

    if (!g_str_equal(buffer, QIO_CHANNEL_WEBSOCK_HTTP_VERSION)) {

        error_setg(errp, "Unsupported HTTP version %s", buffer);

        return 0;

    }

    buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);

    /*

     * Now parse all the header fields of format

     *

     *   $NAME: $VALUE

     *

     * e.g.

     *

     *   Cache-control: no-cache

     */

    do {

        QIOChannelWebsockHTTPHeader *hdr;

        nl = strstr(buffer, QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);

        if (nl) {

            *nl = '\0';

        }

        sep = strchr(buffer, ':');

        if (!sep) {

            error_setg(errp, "Malformed HTTP header");

            return 0;

        }

        *sep = '\0';

        sep++;

        while (*sep == ' ') {

            sep++;

        }

        if (nhdrs >= nhdrsalloc) {

            error_setg(errp, "Too many HTTP headers");

            return 0;

        }

        hdr = &hdrs[nhdrs++];

        hdr->name = buffer;

        hdr->value = sep;

        /* Canonicalize header name for easier identification later */

        for (tmp = hdr->name; *tmp; tmp++) {

            *tmp = g_ascii_tolower(*tmp);

        }

        if (nl) {

            buffer = nl + strlen(QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM);

        }

    } while (nl != NULL);

    return nhdrs;

}


static inline void cris_ftag_d(unsigned int x)

{

	register unsigned int v asm("$r10") = x;

	asm ("ftagd\t[%0]\n" : : "r" (v) );

}


int spapr_h_cas_compose_response(sPAPRMachineState *spapr,
                                 target_ulong addr, target_ulong size,
                                 sPAPROptionVector *ov5_updates)
{
    void *fdt, *fdt_skel;
    sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 };
    if (spapr_hotplugged_dev_before_cas()) {
        return 1;
    size -= sizeof(hdr);
    /* Create skeleton */
    fdt_skel = g_malloc0(size);
    _FDT((fdt_create(fdt_skel, size)));
    _FDT((fdt_begin_node(fdt_skel, "")));
    _FDT((fdt_end_node(fdt_skel)));
    _FDT((fdt_finish(fdt_skel)));
    fdt = g_malloc0(size);
    _FDT((fdt_open_into(fdt_skel, fdt, size)));
    g_free(fdt_skel);
    /* Fixup cpu nodes */
    _FDT((spapr_fixup_cpu_dt(fdt, spapr)));
    if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) {
        return -1;
    /* Pack resulting tree */
    _FDT((fdt_pack(fdt)));
    if (fdt_totalsize(fdt) + sizeof(hdr) > size) {
        trace_spapr_cas_failed(size);
        return -1;
    cpu_physical_memory_write(addr, &hdr, sizeof(hdr));
    cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt));
    trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr));
    g_free(fdt);
    return 0;


static void wav_destroy (void *opaque)

{

    WAVState *wav = opaque;

    uint8_t rlen[4];

    uint8_t dlen[4];

    uint32_t datalen = wav->bytes;

    uint32_t rifflen = datalen + 36;

    if (!wav->f) {

        return;

    }

    le_store (rlen, rifflen, 4);

    le_store (dlen, datalen, 4);

    qemu_fseek (wav->f, 4, SEEK_SET);

    qemu_put_buffer (wav->f, rlen, 4);

    qemu_fseek (wav->f, 32, SEEK_CUR);

    qemu_put_buffer (wav->f, dlen, 4);

    qemu_fclose (wav->f);

    if (wav->path) {

        qemu_free (wav->path);

    }

}


void event_notifier_cleanup(EventNotifier *e)

{

    CloseHandle(e->event);

}


static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,

                             unsigned int c, const unsigned int *div_blocks,

                             unsigned int *js_blocks)

{

    unsigned int b;

    ALSBlockData bd = { 0 };

    bd.ra_block         = ra_frame;

    bd.const_block      = ctx->const_block;

    bd.shift_lsbs       = ctx->shift_lsbs;

    bd.opt_order        = ctx->opt_order;

    bd.store_prev_samples = ctx->store_prev_samples;

    bd.use_ltp          = ctx->use_ltp;

    bd.ltp_lag          = ctx->ltp_lag;

    bd.ltp_gain         = ctx->ltp_gain[0];

    bd.quant_cof        = ctx->quant_cof[0];

    bd.lpc_cof          = ctx->lpc_cof[0];

    bd.prev_raw_samples = ctx->prev_raw_samples;

    bd.raw_samples      = ctx->raw_samples[c];

    for (b = 0; b < ctx->num_blocks; b++) {

        bd.block_length     = div_blocks[b];

        if (read_decode_block(ctx, &bd)) {

            // damaged block, write zero for the rest of the frame

            zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);

            return -1;

        }

        bd.raw_samples += div_blocks[b];

        bd.ra_block     = 0;

    }

    return 0;

}


int ff_load_image(uint8_t *data[4], int linesize[4],

                  int *w, int *h, enum AVPixelFormat *pix_fmt,

                  const char *filename, void *log_ctx)

{

    AVInputFormat *iformat = NULL;

    AVFormatContext *format_ctx = NULL;

    AVCodec *codec;

    AVCodecContext *codec_ctx;

    AVFrame *frame;

    int frame_decoded, ret = 0;

    AVPacket pkt;

    av_register_all();

    iformat = av_find_input_format("image2");

    if ((ret = avformat_open_input(&format_ctx, filename, iformat, NULL)) < 0) {

        av_log(log_ctx, AV_LOG_ERROR,

               "Failed to open input file '%s'\n", filename);

        return ret;

    }

    codec_ctx = format_ctx->streams[0]->codec;

    codec = avcodec_find_decoder(codec_ctx->codec_id);

    if (!codec) {

        av_log(log_ctx, AV_LOG_ERROR, "Failed to find codec\n");

        ret = AVERROR(EINVAL);

        goto end;

    }

    if ((ret = avcodec_open2(codec_ctx, codec, NULL)) < 0) {

        av_log(log_ctx, AV_LOG_ERROR, "Failed to open codec\n");

        goto end;

    }

    if (!(frame = avcodec_alloc_frame()) ) {

        av_log(log_ctx, AV_LOG_ERROR, "Failed to alloc frame\n");

        ret = AVERROR(ENOMEM);

        goto end;

    }

    ret = av_read_frame(format_ctx, &pkt);

    if (ret < 0) {

        av_log(log_ctx, AV_LOG_ERROR, "Failed to read frame from file\n");

        goto end;

    }

    ret = avcodec_decode_video2(codec_ctx, frame, &frame_decoded, &pkt);

    if (ret < 0 || !frame_decoded) {

        av_log(log_ctx, AV_LOG_ERROR, "Failed to decode image from file\n");

        goto end;

    }

    ret = 0;

    *w       = frame->width;

    *h       = frame->height;

    *pix_fmt = frame->format;

    if ((ret = av_image_alloc(data, linesize, *w, *h, *pix_fmt, 16)) < 0)

        goto end;

    ret = 0;

    av_image_copy(data, linesize, (const uint8_t **)frame->data, frame->linesize, *pix_fmt, *w, *h);

end:

    if (codec_ctx)

        avcodec_close(codec_ctx);

    if (format_ctx)

        avformat_close_input(&format_ctx);

    av_freep(&frame);

    if (ret < 0)

        av_log(log_ctx, AV_LOG_ERROR, "Error loading image file '%s'\n", filename);

    return ret;

}


int ff_h264_set_parameter_from_sps(H264Context *h)

{

    if (h->flags & CODEC_FLAG_LOW_DELAY ||

        (h->sps.bitstream_restriction_flag &&

         !h->sps.num_reorder_frames)) {

        if (h->avctx->has_b_frames > 1 || h->delayed_pic[0])

            av_log(h->avctx, AV_LOG_WARNING, "Delayed frames seen. "

                   "Reenabling low delay requires a codec flush.\n");

        else

            h->low_delay = 1;

    }

    if (h->avctx->has_b_frames < 2)

        h->avctx->has_b_frames = !h->low_delay;

    if (h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||

        h->cur_chroma_format_idc      != h->sps.chroma_format_idc) {

        if (h->avctx->codec &&

            h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU &&

            (h->sps.bit_depth_luma != 8 || h->sps.chroma_format_idc > 1)) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "VDPAU decoding does not support video colorspace.\n");

            return AVERROR_INVALIDDATA;

        }

        if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 14 &&

            h->sps.bit_depth_luma != 11 && h->sps.bit_depth_luma != 13) {

            h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;

            h->cur_chroma_format_idc      = h->sps.chroma_format_idc;

            h->pixel_shift                = h->sps.bit_depth_luma > 8;

            ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma,

                            h->sps.chroma_format_idc);

            ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);

            ff_h264qpel_init(&h->h264qpel, h->sps.bit_depth_luma);

            ff_h264_pred_init(&h->hpc, h->avctx->codec_id, h->sps.bit_depth_luma,

                              h->sps.chroma_format_idc);

            ff_videodsp_init(&h->vdsp, h->sps.bit_depth_luma);

        } else {

            av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",

                   h->sps.bit_depth_luma);

            return AVERROR_INVALIDDATA;

        }

    }

    return 0;

}