Example #1
0
static void bitmap_file_unmap(struct bitmap *bitmap)
{
	struct page **map, *sb_page;
	unsigned long *attr;
	int pages;
	unsigned long flags;

	spin_lock_irqsave(&bitmap->lock, flags);
	map = bitmap->filemap;
	bitmap->filemap = NULL;
	attr = bitmap->filemap_attr;
	bitmap->filemap_attr = NULL;
	pages = bitmap->file_pages;
	bitmap->file_pages = 0;
	sb_page = bitmap->sb_page;
	bitmap->sb_page = NULL;
	spin_unlock_irqrestore(&bitmap->lock, flags);

	while (pages--)
		if (map[pages]->index != 0) /* 0 is sb_page, release it below */
			free_buffers(map[pages]);
	kfree(map);
	kfree(attr);

	if (sb_page)
		free_buffers(sb_page);
}
Example #2
0
IGL_INLINE void igl::viewer::OpenGL_state::free()
{
  shader_mesh.free();
  shader_overlay_lines.free();
  shader_overlay_points.free();
  free_buffers();
}
Example #3
0
int main(int argc, char** argv) {

    char* mpi_inbuf;
    char* mpi_outbuf;
    char* farc_inbuf;
    char* farc_outbuf;

    MPI_Init(&argc, &argv);

    test_start("pack(2, [MPI_INT])");
    init_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);

    farc::DDT_Init();
    farc::Datatype* t1 = new farc::PrimitiveDatatype(farc::PrimitiveDatatype::INT);

    int res = compare_ddt_info(MPI_INT, t1);

    farc::DDT_Commit(t1);
    farc::DDT_Pack(farc_inbuf, farc_outbuf, t1, 2);

    int position = 0;
    MPI_Pack(mpi_inbuf, 2, MPI_INT, mpi_outbuf, 20*sizeof(int), &position, MPI_COMM_WORLD);

    res += compare_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);
    free_buffers(&mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);
    test_result(res);

    MPI_Finalize();

    return 0;

}
Example #4
0
void pl_snd_shutdown()
{
  int i;
  sound_ready = 0;
  sound_stop = 1;

  for (i = 0; i < AUDIO_CHANNELS; i++)
  {
    if (sound_stream[i].thread_handle != -1)
    {
      //sceKernelWaitThreadEnd(sound_stream[i].threadhandle,NULL);
      sceKernelDeleteThread(sound_stream[i].thread_handle);
    }

    sound_stream[i].thread_handle = -1;
  }

  for (i = 0; i < AUDIO_CHANNELS; i++)
  {
    if (sound_stream[i].sound_ch_handle != -1)
    {
      sceAudioOutReleasePort(sound_stream[i].sound_ch_handle);
      sound_stream[i].sound_ch_handle = -1;
    }
  }

  free_buffers();
}
Example #5
0
void manual_query()
{
  char query[1024];
  unsigned int qlen;
  GWBUF** tmpbuf;
 
  free_buffers();

  printf("Enter query: ");
  fgets(query,1024,stdin);

  qlen = strnlen(query, 1024);
  if((tmpbuf = malloc(sizeof(GWBUF*)))== NULL){
    printf("Error: cannot allocate enough memory.\n");
    skygw_log_write(LOGFILE_ERROR,"Error: cannot allocate enough memory.\n");
    return;
  }
  instance.buffer = tmpbuf;
  instance.buffer_count = 1;

  instance.buffer[0] = gwbuf_alloc(qlen + 5);
  gwbuf_set_type(instance.buffer[0],GWBUF_TYPE_MYSQL);
  memcpy(instance.buffer[0]->sbuf->data + 5,query,qlen);

  instance.buffer[0]->sbuf->data[0] = (qlen);
  instance.buffer[0]->sbuf->data[1] = (qlen << 8);
  instance.buffer[0]->sbuf->data[2] = (qlen << 16);
  instance.buffer[0]->sbuf->data[3] = 0x00;
  instance.buffer[0]->sbuf->data[4] = 0x03;

}
Example #6
0
void BKE_movieclip_reload(MovieClip *clip)
{
	/* clear cache */
	free_buffers(clip);

	clip->tracking.stabilization.ok = false;

	/* update clip source */
	detect_clip_source(clip);

	clip->lastsize[0] = clip->lastsize[1] = 0;
	movieclip_load_get_szie(clip);

	movieclip_calc_length(clip);

	/* same as for image update -- don't use notifiers because they are not 100% sure to succeeded
	 * (node trees which are not currently visible wouldn't be refreshed)
	 */
	{
		Scene *scene;
		for (scene = G.main->scene.first; scene; scene = scene->id.next) {
			if (scene->nodetree) {
				nodeUpdateID(scene->nodetree, &clip->id);
			}
		}
	}
}
Example #7
0
/***
 * Shuts down the audio systems and frees the buffers.
 */
void audio_shutdown()
{
    int i;
    stop_audio = 1;

    for (i = 0; i < AUDIO_CHANNELS; i++)
    {
        if (audio_status[i].ThreadHandle != -1)
        {
            sceKernelDeleteThread(audio_status[i].ThreadHandle);
        }

        audio_status[i].ThreadHandle = -1;
    }

    for (i = 0; i < AUDIO_CHANNELS; i++)
    {
        if (audio_status[i].Handle != -1)
        {
            sceAudioOutReleasePort(audio_status[i].Handle);
            audio_status[i].Handle = -1;
        }
    }

    free_buffers();
    sceKernelDeleteMutex(audio_mutex);
}
Example #8
0
int main(int argc, char** argv) {

    char* mpi_inbuf;
    char* mpi_outbuf;
    char* farc_inbuf;
    char* farc_outbuf;

    MPI_Init(&argc, &argv);

    test_start("pack(1, hvector[[int], count=2, blklen=2, stride=-5*sizeof(int)])");
    init_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);

    farc::DDT_Init();
    farc::Datatype* t1 = new farc::PrimitiveDatatype(farc::PrimitiveDatatype::INT);
    farc::Datatype* t2 = new farc::HVectorDatatype(2, 2, -5*sizeof(int), t1);
    farc::DDT_Commit(t2);
    farc::DDT_Pack(farc_inbuf+10*sizeof(int), farc_outbuf, t2, 1);

    MPI_Datatype newtype;
    MPI_Type_hvector(2, 2, -5*sizeof(int), MPI_INT, &newtype);
    MPI_Type_commit(&newtype);
    int position = 0;
    MPI_Pack(mpi_inbuf+10*sizeof(int), 1, newtype, mpi_outbuf, 20*sizeof(int), &position, MPI_COMM_WORLD);

    int res = compare_ddt_info(newtype, t2);
    res = compare_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);
    // inspect_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);
    free_buffers(&mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);
    test_result(res);

    MPI_Finalize();

    return 0;

}
Example #9
0
static struct vid_buffer *alloc_buffers(struct v4l2_pix_format *fmt,
                                        int *num_bufs)
{
    struct v4l2_requestbuffers req;
    struct vid_buffer *vb = NULL;
    int offs[3], stride[3];
    int i, j;

    if (get_plane_fmt(fmt, offs, stride))
        return NULL;

    req.count  = *num_bufs;
    req.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT;
    req.memory = V4L2_MEMORY_MMAP;

    xioctl(vid_fd, VIDIOC_REQBUFS, &req);

    if (req.count != *num_bufs)
        fprintf(stderr, "V4L2: requested %d buffers, got %d\n",
                *num_bufs, req.count);

    vb = malloc(req.count * sizeof(*vb));
    if (!vb)
        return NULL;

    for (i = 0; i < req.count; i++) {
        struct v4l2_buffer *buf = &vb[i].buf;
        uint8_t *data;

        buf->index  = i;
        buf->type   = V4L2_BUF_TYPE_VIDEO_OUTPUT;
        buf->memory = V4L2_MEMORY_MMAP;

        xioctl(vid_fd, VIDIOC_QUERYBUF, buf);

        data = mmap(NULL, buf->length, PROT_READ|PROT_WRITE,
                    MAP_SHARED, vid_fd, buf->m.offset);

        if (data == MAP_FAILED) {
            perror("mmap");
            goto err;
        }

        memset(data, 0, buf->length);

        for (j = 0; j < 3; j++)
            vb[i].data[j] = data + offs[j];
    }

    *num_bufs = req.count;
    return vb;
err:
    if (vb)
        free_buffers(vb, req.count);
    return NULL;
}
Example #10
0
static int v4l2_alloc(struct frame_format *ff, unsigned max_mem,
                      struct frame **fr, unsigned *nf)
{
    struct vid_buffer *vb;
    struct frame *frames;
    int offs[3], stride[3];
    int frame_size;
    int nframes;
    int i, j;

    if (get_plane_fmt(&sfmt.fmt.pix, offs, stride))
        return -1;

    switch (sfmt.fmt.pix.pixelformat) {
    case V4L2_PIX_FMT_YUV420:
        frame_size = ff->width * ff->height * 3 / 2;
        break;
    case V4L2_PIX_FMT_NV12:
        frame_size = ff->width * ff->height * 3 / 2;
        break;
    case V4L2_PIX_FMT_YUYV:
        frame_size = ff->width * ff->height * 2;
        break;
    default:
        return -1;
    }

    nframes = MAX(max_mem / frame_size, MIN_FRAMES + 1);
    fprintf(stderr, "V4L2: memman allocating %d frames\n", nframes);

    vb = alloc_buffers(&sfmt.fmt.pix, &nframes);
    if (!vb)
        return -1;

    frames = calloc(nframes, sizeof(*frames));
    if (!frames)
        goto err;

    for (i = 0; i < nframes; i++) {
        frames[i].ff = ff;
        for (j = 0; j < 3; j++) {
            frames[i].virt[j]     = vb[i].data[j];
            frames[i].linesize[j] = stride[j];
        }
    }

    vid_buffers = vb;

    *fr = vid_frames = frames;
    *nf = nframes;

    return 0;
err:
    free_buffers(vb, nframes);
    return -1;
}
Example #11
0
void org_close(void)
{
int d;

	org_stop();
	free_buffers();
	
	for(d=0;d<NUM_DRUMS;d++)
		if (drumtable[d].samples) free(drumtable[d].samples);
}
Example #12
0
HRESULT AllocLAVFrameBuffers(LAVFrame *pFrame, ptrdiff_t stride)
{
  LAVPixFmtDesc desc = getPixelFormatDesc(pFrame->format);

  if (stride < pFrame->width) {
    // Ensure alignment of at least 32 on all planes
    stride = FFALIGN(pFrame->width, 64);
  }

  stride *= desc.codedbytes;

  int alignedHeight = FFALIGN(pFrame->height, 2);

  memset(pFrame->data, 0, sizeof(pFrame->data));
  memset(pFrame->stereo, 0, sizeof(pFrame->stereo));
  memset(pFrame->stride, 0, sizeof(pFrame->stride));
  for (int plane = 0; plane < desc.planes; plane++) {
    ptrdiff_t planeStride = stride / desc.planeWidth[plane];
    size_t size = planeStride * (alignedHeight / desc.planeHeight[plane]);
    pFrame->data[plane]   = (BYTE *)_aligned_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE, 64);
    if (pFrame->data[plane] == nullptr) {
      free_buffers(pFrame);
      return E_OUTOFMEMORY;
    }
    pFrame->stride[plane] = planeStride;
  }

  if (pFrame->flags & LAV_FRAME_FLAG_MVC) {
    for (int plane = 0; plane < desc.planes; plane++) {
      size_t size = pFrame->stride[plane] * (alignedHeight / desc.planeHeight[plane]);
      pFrame->stereo[plane] = (BYTE *)_aligned_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE, 64);
      if (pFrame->stereo[plane] == nullptr) {
        free_buffers(pFrame);
        return E_OUTOFMEMORY;
      }
    }
  }

  pFrame->destruct = &free_buffers;
  pFrame->flags   |= LAV_FRAME_FLAG_BUFFER_MODIFY;

  return S_OK;
}
Example #13
0
/* free all memory involved into manipulating with filesystem */
void reiserfs_free (reiserfs_filsys_t fs)
{
    reiserfs_free_bitmap_blocks(fs);
    
    /* release super block and memory used by filesystem handler */
    brelse (SB_BUFFER_WITH_SB (fs));
    
    free_buffers ();

    free (fs->file_name);
    freemem (fs);
}
Example #14
0
static void cleanup(void)
{
    int i = V4L2_BUF_TYPE_VIDEO_OUTPUT;
    ioctl(vid_fd, VIDIOC_STREAMOFF, &i);

    free_buffers(vid_buffers, num_buffers);
    vid_buffers = NULL;

    close(vid_fd);
    vid_fd = -1;

    pixconv = NULL;
}
Example #15
0
void RTcmix::close()
{
	rtcmix_debug(NULL, "RTcmix::close entered");
	run_status = RT_SHUTDOWN;
	AudioDevice *dev = audioDevice;
	audioDevice = NULL;
	delete dev;
	audio_config = NO;
	free_buffers();
#ifdef MULTI_THREAD
	InputFile::destroyConversionBuffers();
#endif
	rtcmix_debug(NULL, "RTcmix::close exited");
}
Example #16
0
/*
 * Run performance tests for a number of different sizes and cached/uncached
 * permutations.
 */
static int
perf_test(void)
{
	const unsigned num_buf_sizes = sizeof(buf_sizes) / sizeof(buf_sizes[0]);
	unsigned i;
	int ret;

	ret = init_buffers();
	if (ret != 0)
		return ret;

#if TEST_VALUE_RANGE != 0
	/* Setup buf_sizes array, if required */
	for (i = 0; i < TEST_VALUE_RANGE; i++)
		buf_sizes[i] = i;
#endif

	/* See function comment */
	do_uncached_write(large_buf_write, 0, small_buf_read, 1, SMALL_BUFFER_SIZE);

	printf("\n** rte_memcpy() - memcpy perf. tests (C = compile-time constant) **\n"
	       "======= ============== ============== ============== ==============\n"
	       "   Size Cache to cache   Cache to mem   Mem to cache     Mem to mem\n"
	       "(bytes)        (ticks)        (ticks)        (ticks)        (ticks)\n"
	       "------- -------------- -------------- -------------- --------------");

	/* Do tests where size is a variable */
	for (i = 0; i < num_buf_sizes; i++) {
		ALL_PERF_TESTS_FOR_SIZE((size_t)buf_sizes[i]);
	}
	printf("\n------- -------------- -------------- -------------- --------------");
	/* Do tests where size is a compile-time constant */
	ALL_PERF_TESTS_FOR_SIZE(63U);
	ALL_PERF_TESTS_FOR_SIZE(64U);
	ALL_PERF_TESTS_FOR_SIZE(65U);
	ALL_PERF_TESTS_FOR_SIZE(255U);
	ALL_PERF_TESTS_FOR_SIZE(256U);
	ALL_PERF_TESTS_FOR_SIZE(257U);
	ALL_PERF_TESTS_FOR_SIZE(1023U);
	ALL_PERF_TESTS_FOR_SIZE(1024U);
	ALL_PERF_TESTS_FOR_SIZE(1025U);
	ALL_PERF_TESTS_FOR_SIZE(1518U);

	printf("\n======= ============== ============== ============== ==============\n\n");

	free_buffers();

	return 0;
}
Example #17
0
void BKE_movieclip_reload(MovieClip *clip)
{
    /* clear cache */
    free_buffers(clip);

    clip->tracking.stabilization.ok = FALSE;

    /* update clip source */
    if (BLI_testextensie_array(clip->name, imb_ext_movie))
        clip->source = MCLIP_SRC_MOVIE;
    else
        clip->source = MCLIP_SRC_SEQUENCE;

    movieclip_calc_length(clip);
}
Example #18
0
// Destructor for the class.
brutefir::~brutefir()
{
    free_buffers();
    free_coeff();

    // free objects
    delete m_convolver;
    delete m_dither;

    // free configuration structure
    if (bfconf != NULL)
    {
        free(bfconf);
        bfconf = NULL;
    }
}
Example #19
0
void
RTcmix::free_globals()
{
	free_buffers();
	free_bus_config();
	freefuncs();
	delete [] rtQueue;
	rtQueue = NULL;
	delete rtHeap;
	rtHeap = NULL;
#ifdef MULTI_THREAD
	delete taskManager;
	taskManager = NULL;
	InputFile::destroyConversionBuffers();
#endif

}
static int pxa3xx_gcu_remove(struct platform_device *dev)
{
	struct pxa3xx_gcu_priv *priv = platform_get_drvdata(dev);
	struct resource *r = priv->resource_mem;

	pxa3xx_gcu_wait_idle(priv);

	misc_deregister(&priv->misc_dev);
	dma_free_coherent(&dev->dev, SHARED_SIZE,
			priv->shared, priv->shared_phys);
	iounmap(priv->mmio_base);
	release_mem_region(r->start, resource_size(r));
	clk_disable(priv->clk);
	free_buffers(dev, priv);
	kfree(priv);

	return 0;
}
Example #21
0
void
RTcmix::free_globals()
{
	rtcmix_debug(NULL, "RTcmix::free_globals entered");
	free_buffers();
	free_bus_config();
	freefuncs();
	delete [] rtQueue;
	rtQueue = NULL;
	delete rtHeap;
	rtHeap = NULL;
	delete [] inputFileTable;
	inputFileTable = NULL;
	
	delete [] AuxToAuxPlayList;
	AuxToAuxPlayList = NULL;
	delete [] ToAuxPlayList;
	ToAuxPlayList = NULL;
	delete [] ToOutPlayList;
	ToAuxPlayList = NULL;
	delete [] BusConfigs;
	BusConfigs = NULL;
	
	// Reset state of all global vars
	runToOffset				= false;
	bufOffset				= 0;
	rtsetparams_called 		= 0;
	audioLoopStarted 		= 0;
	audio_config 			= 1;
	elapsed 				= 0;
	run_status      		= RT_GOOD;
	rtrecord 				= false;
	rtfileit 				= 0;
	rtoutfile 				= 0;
	output_data_format 		= -1;
	output_header_type 		= -1;
	
#ifdef MULTI_THREAD
	delete taskManager;
	taskManager = NULL;
	InputFile::destroyConversionBuffers();
#endif

}
Example #22
0
static bool init_buffers(void)
{
int i;

	// free the old buffers, as we're probably going to change their size here in a sec
	free_buffers();
	
	/* figure some stuff out real quick about buffer lengths --- */
	
	// convert the ms-per-beat stuff into samples
	song.samples_per_beat = MSToSamples(song.ms_per_beat);
	song.note_closing_samples = MSToSamples(song.ms_of_last_beat_of_note);
	// take the suggestion on cache ahead time (which is in ms) and figure out how many beats that is
	buffer_beats = (cache_ahead_time / song.ms_per_beat) + 1;
	if (buffer_beats < 3) buffer_beats = 3;
	
	// now figure out how many samples that is.
	buffer_samples = (buffer_beats * song.samples_per_beat);
	// now figure out how many bytes THAT is.
	outbuffer_size_bytes = buffer_samples * 2 * 2;		// @ 16-bits, and stereo sound
	
	
	// initilize the per-channel output buffers
	for(i=0;i<16;i++)
	{
		note_channel[i].outbuffer = (signed short *)malloc(outbuffer_size_bytes);
		note_channel[i].number = i;
		//memset(note_channel[i].outbuffer, 0, outbuffer_size_bytes);
	}
	
	// initilize the final (mixed) output buffers
	for(i=0;i<2;i++)
	{
		final_buffer[i].samples = (signed short *)malloc(outbuffer_size_bytes);
		//memset(final_buffer[i].samples, 0, outbuffer_size_bytes);
	}
	
	return 0;
}
Example #23
0
static char		*modulo_operation(char *op1, char *op2,
					  t_op *operation)
{
  char			*op_cpy1;
  char			*op_cpy2;
  char			*res1;
  char			*res2;
  char			*res3;

  if (op2[0] == operation->operands[0])
    {
      my_puterror("Division by zero\n");
      return (NULL);
    }
  if (epure_sym(op1, op2, &op_cpy1, &op_cpy2,
		operation->operators[3]) == RETURN_FAILURE)
    return (NULL);
  res1 = inf_div(op_cpy1, op_cpy2, operation->operands, operation->operators[3]);
  res2 = inf_mul(op_cpy2, res1, operation->operands, operation->operators[3]);
  res3 = inf_sub(op_cpy1, res2, operation->operands, operation->operators[3]);
  free_buffers(&op_cpy1, &op_cpy2, &res1, &res2);
  return (res3);
}
Example #24
0
int main(int argc, char** argv) {

    char* mpi_inbuf;
    char* mpi_outbuf;
    char* farc_inbuf;
    char* farc_outbuf;

    MPI_Init(&argc, &argv);

    test_start("unpack(2, hindexed[{(1*MPI_INT, offset=4), (3*MPI_INT, offset=16), (2*MPI_INT, offset=32)}])");
    init_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);

    MPI_Datatype mpitype; 
    int blocklen[3] = {1, 3, 2};
    MPI_Aint disp[3] = {4, 16, 32};

    MPI_Type_create_hindexed(3, blocklen, disp, MPI_INT, &mpitype);
    MPI_Type_commit(&mpitype);

    farc::DDT_Init();
    farc::Datatype* t1 = new farc::PrimitiveDatatype(farc::PrimitiveDatatype::INT);
    farc::Datatype* t2 = new farc::HIndexedDatatype(3, blocklen, disp, t1);
    farc::DDT_Commit(t2);
    farc::DDT_Unpack(farc_inbuf, farc_outbuf, t2, 2);

    int position = 0;
    MPI_Unpack(mpi_inbuf, 20*sizeof(int), &position, mpi_outbuf, 2, mpitype, MPI_COMM_WORLD);

    int res = compare_buffers(20*sizeof(int), &mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);
    free_buffers(&mpi_inbuf, &farc_inbuf, &mpi_outbuf, &farc_outbuf);
    test_result(res);

    MPI_Finalize();

    return 0;

}
Example #25
0
/***
 * Initializes the audio buffers and a callback thread for each channel.
 */
int setup_audio()
{
    int i, j, failed;

    stop_audio = 0;

    for (i = 0; i < AUDIO_CHANNELS; i++)
    {
        audio_status[i].Handle = -1;
        audio_status[i].ThreadHandle = -1;
        audio_status[i].LeftVolume = PSP_AUDIO_MAX_VOLUME;
        audio_status[i].RightVolume = PSP_AUDIO_MAX_VOLUME;
        audio_status[i].Callback = NULL;
        audio_status[i].Userdata = NULL;

        for (j = 0; j < 2; j++)
        {
            audio_buffer[i][j] = NULL;
            audio_buffer_samples[i][j] = 0;
        }
    }

    /* Initialize buffers */
    for (i = 0; i < AUDIO_CHANNELS; i++)
    {
        for (j = 0; j < 2; j++)
        {
            if (!(audio_buffer[i][j] = (short*)malloc(AUDIO_SAMPLE_COUNT * sizeof(PspStereoSample))))
            {
                printf("Couldn't initialize audio buffer for channel %i, bailing.", i);
                free_buffers();
                sceKernelExitProcess(0);

                return 0;
            }

            audio_buffer_samples[i][j] = AUDIO_SAMPLE_COUNT;
        }
    }

    /* Initialize channels */
    for (i = 0, failed = 0; i < AUDIO_CHANNELS; i++)
    {
        audio_status[i].Handle = sceAudioOutOpenPort(SCE_AUDIO_OUT_PORT_TYPE_VOICE, AUDIO_SAMPLE_COUNT, AUDIO_OUTPUT_RATE, SCE_AUDIO_OUT_MODE_STEREO);

        if (audio_status[i].Handle < 0)
        {
            failed = 1;
            break;
        }
    }

    if (failed)
    {
        for (i = 0; i < AUDIO_CHANNELS; i++)
        {
            if (audio_status[i].Handle != -1)
            {
                sceAudioOutReleasePort(audio_status[i].Handle);
                audio_status[i].Handle = -1;
            }
        }

        printf("Couldn't open audio port for the device, bailing.");
        free_buffers();
        sceKernelExitProcess(0);

        return 0;
    }

    char label[16];
    strcpy(label, "audiotX");

    for (i = 0; i < AUDIO_CHANNELS; i++)
    {
        label[6] = '0' + i;
        audio_status[i].ThreadHandle =
            sceKernelCreateThread(label, (void*)&audio_channel_thread, 0x10000100, 0x10000,
                0, 0, NULL);

        if (audio_status[i].ThreadHandle < 0)
        {
            audio_status[i].ThreadHandle = -1;
            failed = 1;
            break;
        }

        if (sceKernelStartThread(audio_status[i].ThreadHandle, sizeof(i), &i) != 0)
        {
            failed = 1;
            break;
        }
    }

    if (failed)
    {
        stop_audio = 1;

        for (i = 0; i < AUDIO_CHANNELS; i++)
        {
            if (audio_status[i].ThreadHandle != -1)
            {
                sceKernelDeleteThread(audio_status[i].ThreadHandle);
            }

            audio_status[i].ThreadHandle = -1;
        }


        printf("Couldn't initialize audio callback thread. Bailing.");
        sceKernelExitProcess(0);

        return 0;
    }

    // initialize the buffer our libretro audio callback will fill with data as it's available
    retro_audio_callback_buffer = (int16_t*)malloc(sizeof(int16_t) * AUDIO_SAMPLE_COUNT * 4);

    if (!retro_audio_callback_buffer)
    {
        printf("Couldn't initialize retro_audio_callback_buffer. Bailing.");
        sceKernelExitProcess(0);
    }

    curr_buffer_frames = 0;

    // setup our callbacks
    set_audio_channel_callback(0, audio_callback, 0);

    // initialize the audio buffer mutex
    audio_mutex = sceKernelCreateMutex("AudioMutex", 0, 1, 0);

    return AUDIO_SAMPLE_COUNT;
}
Example #26
0
void BKE_movieclip_free(MovieClip *clip)
{
	free_buffers(clip);

	BKE_tracking_free(&clip->tracking);
}
Example #27
0
void BKE_movieclip_clear_cache(MovieClip *clip)
{
	free_buffers(clip);
}
Example #28
0
File: main.c Project: dr1s/rom_tool
int main(int argc, char *argv[])
{	
	//Filter Out Bad number of arguments
	if (argc < 3){
		printf("[!] Must Specify Arguments\n");
		help(argv[0]);
		return ARGC_FAIL;
	}
	
	CCI_CONTEXT *ctx = malloc(sizeof(CCI_CONTEXT));
	memset(ctx,0x0,sizeof(CCI_CONTEXT));
		
	for(int i = 1; i < argc; i++){
		if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0){
			help(argv[0]);
			free_buffers(ctx);
			return 0;
		}
		else if(strcmp(argv[i], "-i") == 0 || strcmp(argv[i], "--info") == 0)
			ctx->flags[info] = True;
		else if(strcmp(argv[i], "-p") == 0 || strcmp(argv[i], "--partition_info") == 0)
			ctx->flags[part_info] = True;
		else if(strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "--restore") == 0)
			ctx->flags[restore] = True;
		else if(strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--trim") == 0)
			ctx->flags[trim] = True;
		else if(strcmp(argv[i], "-u") == 0 || strcmp(argv[i], "--remove_update") == 0){
			ctx->flags[trim] = True;
			ctx->flags[remove_update_partition] = True;
		}
		else if(strcmp(argv[i], "-x") == 0 && ctx->flags[extract] == False && i+1 < (argc - 1)){
			ctx->flags[extract] = True;
			ctx->outfile.arg_len = strlen(argv[i+1]);
			ctx->outfile.argument = malloc(ctx->outfile.arg_len);
			if(ctx->outfile.argument == NULL){
				puts("[!] MEM ERROR\n");
				return Fail;
			}
			memcpy(ctx->outfile.argument,argv[i+1],ctx->outfile.arg_len+1);
		}
		else if(strncmp(argv[i], "--extract=",10) == 0 && ctx->flags[extract] == False){
			ctx->flags[extract] = True;
			ctx->outfile.arg_len = strlen(argv[i]+10);
			ctx->outfile.argument = malloc(ctx->outfile.arg_len);
			if(ctx->outfile.argument == NULL){
				puts("[!] MEM ERROR\n");
				return Fail;
			}
			memcpy(ctx->outfile.argument,argv[i]+10,ctx->outfile.arg_len+1);
		}
		else if(i == argc-1){
			FILE *cci = fopen(argv[i],"rb");
			if(cci == NULL){
				printf("[!] Failed to open '%s', last argument must be a CCI file.\n",argv[i]);
				return Fail;
			}
			ctx->cci_file.arg_len = strlen(argv[i]);
			ctx->cci_file.argument = malloc(ctx->cci_file.arg_len+1);
			if(ctx->cci_file.argument == NULL){
				puts("[!] MEM ERROR\n");
				return Fail;
			}
			memcpy(ctx->cci_file.argument,argv[i],ctx->cci_file.arg_len+1);
			fclose(cci);
		}
	}
	
	if(ctx->flags[restore] == True && ctx->flags[trim] == True){
		printf("[!] You cannot trim and restore a CCI at the same time\n");
		help(argv[0]);
		free_buffers(ctx);
		return 1;
	}
	
	int Action = 0;
	for(int i = 0; i < 6; i++){
		if(ctx->flags[i] == True)
			Action++;
	}
	if(!Action){
		printf("[!] Nothing To Do\n");
		help(argv[0]);
		free_buffers(ctx);
		return 1;
	}

	if(NCSDProcess(ctx) != 0)
		goto fail_cleanup;
	
	printf("[*] Completed Successfully\n");
	free_buffers(ctx);
	return 0;
fail_cleanup:
	printf("[!] Failed\n");
	free_buffers(ctx);
	return 1;
}
Example #29
0
static int __devinit
pxa3xx_gcu_probe(struct platform_device *dev)
{
	int i, ret, irq;
	struct resource *r;
	struct pxa3xx_gcu_priv *priv;

	priv = kzalloc(sizeof(struct pxa3xx_gcu_priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	for (i = 0; i < 8; i++) {
		ret = add_buffer(dev, priv);
		if (ret) {
			dev_err(&dev->dev, "failed to allocate DMA memory\n");
			goto err_free_priv;
		}
	}

	init_waitqueue_head(&priv->wait_idle);
	init_waitqueue_head(&priv->wait_free);
	spin_lock_init(&priv->spinlock);

	/* we allocate the misc device structure as part of our own allocation,
	 * so we can get a pointer to our priv structure later on with
	 * container_of(). This isn't really necessary as we have a fixed minor
	 * number anyway, but this is to avoid statics. */

	priv->misc_fops.owner	= THIS_MODULE;
	priv->misc_fops.write	= pxa3xx_gcu_misc_write;
	priv->misc_fops.unlocked_ioctl = pxa3xx_gcu_misc_ioctl;
	priv->misc_fops.mmap	= pxa3xx_gcu_misc_mmap;

	priv->misc_dev.minor	= MISCDEV_MINOR,
	priv->misc_dev.name	= DRV_NAME,
	priv->misc_dev.fops	= &priv->misc_fops,

	/* register misc device */
	ret = misc_register(&priv->misc_dev);
	if (ret < 0) {
		dev_err(&dev->dev, "misc_register() for minor %d failed\n",
			MISCDEV_MINOR);
		goto err_free_priv;
	}

	/* handle IO resources */
	r = platform_get_resource(dev, IORESOURCE_MEM, 0);
	if (r == NULL) {
		dev_err(&dev->dev, "no I/O memory resource defined\n");
		ret = -ENODEV;
		goto err_misc_deregister;
	}

	if (!request_mem_region(r->start, resource_size(r), dev->name)) {
		dev_err(&dev->dev, "failed to request I/O memory\n");
		ret = -EBUSY;
		goto err_misc_deregister;
	}

	priv->mmio_base = ioremap_nocache(r->start, resource_size(r));
	if (!priv->mmio_base) {
		dev_err(&dev->dev, "failed to map I/O memory\n");
		ret = -EBUSY;
		goto err_free_mem_region;
	}

	/* allocate dma memory */
	priv->shared = dma_alloc_coherent(&dev->dev, SHARED_SIZE,
					  &priv->shared_phys, GFP_KERNEL);

	if (!priv->shared) {
		dev_err(&dev->dev, "failed to allocate DMA memory\n");
		ret = -ENOMEM;
		goto err_free_io;
	}

	/* enable the clock */
	priv->clk = clk_get(&dev->dev, NULL);
	if (IS_ERR(priv->clk)) {
		dev_err(&dev->dev, "failed to get clock\n");
		ret = -ENODEV;
		goto err_free_dma;
	}

	ret = clk_enable(priv->clk);
	if (ret < 0) {
		dev_err(&dev->dev, "failed to enable clock\n");
		goto err_put_clk;
	}

	/* request the IRQ */
	irq = platform_get_irq(dev, 0);
	if (irq < 0) {
		dev_err(&dev->dev, "no IRQ defined\n");
		ret = -ENODEV;
		goto err_put_clk;
	}

	ret = request_irq(irq, pxa3xx_gcu_handle_irq,
			  0, DRV_NAME, priv);
	if (ret) {
		dev_err(&dev->dev, "request_irq failed\n");
		ret = -EBUSY;
		goto err_put_clk;
	}

	platform_set_drvdata(dev, priv);
	priv->resource_mem = r;
	pxa3xx_gcu_reset(priv);
	pxa3xx_gcu_init_debug_timer();

	dev_info(&dev->dev, "registered @0x%p, DMA 0x%p (%d bytes), IRQ %d\n",
			(void *) r->start, (void *) priv->shared_phys,
			SHARED_SIZE, irq);
	return 0;

err_put_clk:
	clk_disable(priv->clk);
	clk_put(priv->clk);

err_free_dma:
	dma_free_coherent(&dev->dev, SHARED_SIZE,
			priv->shared, priv->shared_phys);

err_free_io:
	iounmap(priv->mmio_base);

err_free_mem_region:
	release_mem_region(r->start, resource_size(r));

err_misc_deregister:
	misc_deregister(&priv->misc_dev);

err_free_priv:
	platform_set_drvdata(dev, NULL);
	free_buffers(dev, priv);
	kfree(priv);
	return ret;
}
Example #30
0
static void test_communication(void)
{
    int ret;

    WSADATA wsa_data;
    SOCKET sock;
    struct hostent *host;
    struct sockaddr_in addr;

    SECURITY_STATUS status;
    ULONG attrs;

    SCHANNEL_CRED cred;
    CredHandle cred_handle;
    CtxtHandle context;
    SecPkgCredentials_NamesA names;
    SecPkgContext_StreamSizes sizes;
    SecPkgContext_ConnectionInfo conn_info;
    CERT_CONTEXT *cert;

    SecBufferDesc buffers[2];
    SecBuffer *buf;
    unsigned buf_size = 4000;
    unsigned char *data;
    unsigned data_size;

    if (!pAcquireCredentialsHandleA || !pFreeCredentialsHandle ||
        !pInitializeSecurityContextA || !pDeleteSecurityContext ||
        !pQueryContextAttributesA || !pDecryptMessage || !pEncryptMessage)
    {
        skip("Required secur32 functions not available\n");
        return;
    }

    /* Create a socket and connect to www.winehq.org */
    ret = WSAStartup(0x0202, &wsa_data);
    if (ret)
    {
        skip("Can't init winsock 2.2\n");
        return;
    }

    host = gethostbyname("www.winehq.org");
    if (!host)
    {
        skip("Can't resolve www.winehq.org\n");
        return;
    }

    addr.sin_family = host->h_addrtype;
    addr.sin_addr = *(struct in_addr *)host->h_addr_list[0];
    addr.sin_port = htons(443);
    sock = socket(host->h_addrtype, SOCK_STREAM, 0);
    if (sock == SOCKET_ERROR)
    {
        skip("Can't create socket\n");
        return;
    }

    ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
    if (ret == SOCKET_ERROR)
    {
        skip("Can't connect to www.winehq.org\n");
        return;
    }

    /* Create client credentials */
    init_cred(&cred);
    cred.grbitEnabledProtocols = SP_PROT_TLS1_CLIENT;
    cred.dwFlags = SCH_CRED_NO_DEFAULT_CREDS|SCH_CRED_MANUAL_CRED_VALIDATION;

    status = pAcquireCredentialsHandleA(NULL, (SEC_CHAR *)UNISP_NAME_A, SECPKG_CRED_OUTBOUND, NULL,
        &cred, NULL, NULL, &cred_handle, NULL);
    ok(status == SEC_E_OK, "AcquireCredentialsHandleA failed: %08x\n", status);
    if (status != SEC_E_OK) return;

    /* Initialize the connection */
    init_buffers(&buffers[0], 4, buf_size);
    init_buffers(&buffers[1], 4, buf_size);

    buffers[0].pBuffers[0].BufferType = SECBUFFER_TOKEN;
    status = pInitializeSecurityContextA(&cred_handle, NULL, (SEC_CHAR *)"localhost",
        ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
        0, 0, NULL, 0, &context, &buffers[0], &attrs, NULL);
    ok(status == SEC_I_CONTINUE_NEEDED, "Expected SEC_I_CONTINUE_NEEDED, got %08x\n", status);

    buffers[1].cBuffers = 1;
    buffers[1].pBuffers[0].BufferType = SECBUFFER_TOKEN;
    buffers[0].pBuffers[0].cbBuffer = 1;
    memset(buffers[1].pBuffers[0].pvBuffer, 0xfa, buf_size);
    status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, &buffers[1], 0, NULL, &buffers[0], &attrs, NULL);
todo_wine
    ok(status == SEC_E_INVALID_TOKEN, "Expected SEC_E_INVALID_TOKEN, got %08x\n", status);
todo_wine
    ok(buffers[0].pBuffers[0].cbBuffer == 0, "Output buffer size was not set to 0.\n");

    buffers[1].cBuffers = 1;
    buffers[1].pBuffers[0].BufferType = SECBUFFER_TOKEN;
    buffers[0].pBuffers[0].cbBuffer = 1;
    memset(buffers[1].pBuffers[0].pvBuffer, 0, buf_size);
    status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, &buffers[1], 0, NULL, &buffers[0], &attrs, NULL);
    ok(status == SEC_E_INVALID_TOKEN, "Expected SEC_E_INVALID_TOKEN, got %08x\n", status);
todo_wine
    ok(buffers[0].pBuffers[0].cbBuffer == 0, "Output buffer size was not set to 0.\n");

    buffers[0].pBuffers[0].cbBuffer = 0;
    status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, &buffers[1], 0, NULL, &buffers[0], &attrs, NULL);
todo_wine
    ok(status == SEC_E_INSUFFICIENT_MEMORY || status == SEC_E_INVALID_TOKEN,
       "Expected SEC_E_INSUFFICIENT_MEMORY or SEC_E_INVALID_TOKEN, got %08x\n", status);

    buffers[0].pBuffers[0].cbBuffer = buf_size;

    status = pInitializeSecurityContextA(&cred_handle, NULL, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, NULL, 0, &context, &buffers[0], &attrs, NULL);
    ok(status == SEC_I_CONTINUE_NEEDED, "Expected SEC_I_CONTINUE_NEEDED, got %08x\n", status);

    buf = &buffers[0].pBuffers[0];
    send(sock, buf->pvBuffer, buf->cbBuffer, 0);
    buf->cbBuffer = buf_size;

    status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, NULL, 0, NULL, &buffers[0], &attrs, NULL);
    ok(status == SEC_E_INCOMPLETE_MESSAGE, "Got unexpected status %#x.\n", status);
    ok(buffers[0].pBuffers[0].cbBuffer == buf_size, "Output buffer size changed.\n");
    ok(buffers[0].pBuffers[0].BufferType == SECBUFFER_TOKEN, "Output buffer type changed.\n");

    buffers[1].cBuffers = 4;
    buffers[1].pBuffers[0].cbBuffer = 0;

    status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, &buffers[1], 0, NULL, &buffers[0], &attrs, NULL);
    ok(status == SEC_E_INCOMPLETE_MESSAGE, "Got unexpected status %#x.\n", status);
    ok(buffers[0].pBuffers[0].cbBuffer == buf_size, "Output buffer size changed.\n");
    ok(buffers[0].pBuffers[0].BufferType == SECBUFFER_TOKEN, "Output buffer type changed.\n");

    buf = &buffers[1].pBuffers[0];
    buf->cbBuffer = buf_size;
    ret = receive_data(sock, buf);
    if (ret == -1)
        return;

    buffers[1].pBuffers[0].cbBuffer = 4;
    status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, &buffers[1], 0, NULL, &buffers[0], &attrs, NULL);
    ok(status == SEC_E_INCOMPLETE_MESSAGE, "Got unexpected status %#x.\n", status);
    ok(buffers[0].pBuffers[0].cbBuffer == buf_size, "Output buffer size changed.\n");
    ok(buffers[0].pBuffers[0].BufferType == SECBUFFER_TOKEN, "Output buffer type changed.\n");

    buffers[1].pBuffers[0].cbBuffer = 5;
    status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, &buffers[1], 0, NULL, &buffers[0], &attrs, NULL);
    ok(status == SEC_E_INCOMPLETE_MESSAGE, "Got unexpected status %#x.\n", status);
    ok(buffers[0].pBuffers[0].cbBuffer == buf_size, "Output buffer size changed.\n");
    ok(buffers[0].pBuffers[0].BufferType == SECBUFFER_TOKEN, "Output buffer type changed.\n");

    buffers[1].pBuffers[0].cbBuffer = ret;
    status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, &buffers[1], 0, NULL, &buffers[0], &attrs, NULL);
    buffers[1].pBuffers[0].cbBuffer = buf_size;
    while (status == SEC_I_CONTINUE_NEEDED)
    {
        buf = &buffers[0].pBuffers[0];
        send(sock, buf->pvBuffer, buf->cbBuffer, 0);
        buf->cbBuffer = buf_size;

        buf = &buffers[1].pBuffers[0];
        ret = receive_data(sock, buf);
        if (ret == -1)
            return;

        buf->BufferType = SECBUFFER_TOKEN;

        status = pInitializeSecurityContextA(&cred_handle, &context, (SEC_CHAR *)"localhost",
            ISC_REQ_CONFIDENTIALITY|ISC_REQ_STREAM,
            0, 0, &buffers[1], 0, NULL, &buffers[0], &attrs, NULL);
        buffers[1].pBuffers[0].cbBuffer = buf_size;
    }

    ok(status == SEC_E_OK || broken(status == SEC_E_INVALID_TOKEN) /* WinNT */,
        "InitializeSecurityContext failed: %08x\n", status);
    if(status != SEC_E_OK) {
        win_skip("Handshake failed\n");
        return;
    }

    status = pQueryCredentialsAttributesA(&cred_handle, SECPKG_CRED_ATTR_NAMES, &names);
    ok(status == SEC_E_NO_CREDENTIALS || status == SEC_E_UNSUPPORTED_FUNCTION /* before Vista */, "expected SEC_E_NO_CREDENTIALS, got %08x\n", status);

    status = pQueryContextAttributesA(&context, SECPKG_ATTR_REMOTE_CERT_CONTEXT, (void*)&cert);
    ok(status == SEC_E_OK, "QueryContextAttributesW(SECPKG_ATTR_REMOTE_CERT_CONTEXT) failed: %08x\n", status);
    if(status == SEC_E_OK) {
        test_remote_cert(cert);
        CertFreeCertificateContext(cert);
    }

    status = pQueryContextAttributesA(&context, SECPKG_ATTR_CONNECTION_INFO, (void*)&conn_info);
    ok(status == SEC_E_OK, "QueryContextAttributesW(SECPKG_ATTR_CONNECTION_INFO) failed: %08x\n", status);
    if(status == SEC_E_OK) {
        ok(conn_info.dwCipherStrength >= 128, "conn_info.dwCipherStrength = %d\n", conn_info.dwCipherStrength);
        ok(conn_info.dwHashStrength >= 128, "conn_info.dwHashStrength = %d\n", conn_info.dwHashStrength);
    }

    status = pQueryContextAttributesA(&context, SECPKG_ATTR_STREAM_SIZES, &sizes);
    ok(status == SEC_E_OK, "QueryContextAttributesW(SECPKG_ATTR_STREAM_SIZES) failed: %08x\n", status);

    reset_buffers(&buffers[0]);

    /* Send a simple request so we get data for testing DecryptMessage */
    buf = &buffers[0].pBuffers[0];
    data = buf->pvBuffer;
    buf->BufferType = SECBUFFER_STREAM_HEADER;
    buf->cbBuffer = sizes.cbHeader;
    ++buf;
    buf->BufferType = SECBUFFER_DATA;
    buf->pvBuffer = data + sizes.cbHeader;
    buf->cbBuffer = sizeof(http_request) - 1;
    memcpy(buf->pvBuffer, http_request, sizeof(http_request) - 1);
    ++buf;
    buf->BufferType = SECBUFFER_STREAM_TRAILER;
    buf->pvBuffer = data + sizes.cbHeader + sizeof(http_request) -1;
    buf->cbBuffer = sizes.cbTrailer;

    status = pEncryptMessage(&context, 0, &buffers[0], 0);
    ok(status == SEC_E_OK, "EncryptMessage failed: %08x\n", status);
    if (status != SEC_E_OK)
        return;

    buf = &buffers[0].pBuffers[0];
    send(sock, buf->pvBuffer, buffers[0].pBuffers[0].cbBuffer + buffers[0].pBuffers[1].cbBuffer + buffers[0].pBuffers[2].cbBuffer, 0);

    reset_buffers(&buffers[0]);
    buf->cbBuffer = buf_size;
    data_size = receive_data(sock, buf);

    /* Too few buffers */
    --buffers[0].cBuffers;
    status = pDecryptMessage(&context, &buffers[0], 0, NULL);
    ok(status == SEC_E_INVALID_TOKEN, "Expected SEC_E_INVALID_TOKEN, got %08x\n", status);

    /* No data buffer */
    ++buffers[0].cBuffers;
    status = pDecryptMessage(&context, &buffers[0], 0, NULL);
    ok(status == SEC_E_INVALID_TOKEN, "Expected SEC_E_INVALID_TOKEN, got %08x\n", status);

    /* Two data buffers */
    buffers[0].pBuffers[0].BufferType = SECBUFFER_DATA;
    buffers[0].pBuffers[1].BufferType = SECBUFFER_DATA;
    status = pDecryptMessage(&context, &buffers[0], 0, NULL);
    ok(status == SEC_E_INVALID_TOKEN, "Expected SEC_E_INVALID_TOKEN, got %08x\n", status);

    /* Too few empty buffers */
    buffers[0].pBuffers[1].BufferType = SECBUFFER_EXTRA;
    status = pDecryptMessage(&context, &buffers[0], 0, NULL);
    ok(status == SEC_E_INVALID_TOKEN, "Expected SEC_E_INVALID_TOKEN, got %08x\n", status);

    /* Incomplete data */
    buffers[0].pBuffers[1].BufferType = SECBUFFER_EMPTY;
    buffers[0].pBuffers[0].cbBuffer = (data[3]<<8) | data[4];
    status = pDecryptMessage(&context, &buffers[0], 0, NULL);
    ok(status == SEC_E_INCOMPLETE_MESSAGE, "Expected SEC_E_INCOMPLETE_MESSAGE, got %08x\n", status);
    ok(buffers[0].pBuffers[0].BufferType == SECBUFFER_MISSING, "Expected first buffer to be SECBUFFER_MISSING\n");
    ok(buffers[0].pBuffers[0].cbBuffer == 5, "Expected first buffer to be a five bytes\n");

    buffers[0].pBuffers[0].cbBuffer = data_size;
    buffers[0].pBuffers[0].BufferType = SECBUFFER_DATA;
    buffers[0].pBuffers[1].BufferType = SECBUFFER_EMPTY;
    status = pDecryptMessage(&context, &buffers[0], 0, NULL);
    ok(status == SEC_E_OK, "DecryptMessage failed: %08x\n", status);
    if (status == SEC_E_OK)
    {
        ok(buffers[0].pBuffers[0].BufferType == SECBUFFER_STREAM_HEADER, "Expected first buffer to be SECBUFFER_STREAM_HEADER\n");
        ok(buffers[0].pBuffers[1].BufferType == SECBUFFER_DATA, "Expected second buffer to be SECBUFFER_DATA\n");
        ok(buffers[0].pBuffers[2].BufferType == SECBUFFER_STREAM_TRAILER, "Expected third buffer to be SECBUFFER_STREAM_TRAILER\n");

        data = buffers[0].pBuffers[1].pvBuffer;
        data[buffers[0].pBuffers[1].cbBuffer] = 0;
    }

    pDeleteSecurityContext(&context);
    pFreeCredentialsHandle(&cred_handle);

    free_buffers(&buffers[0]);
    free_buffers(&buffers[1]);

    closesocket(sock);
}