SkStream.cpp File Reference

#include "include/core/SkStream.h"
#include "include/core/SkData.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkAlign.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTFitsIn.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkSafeMath.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkStreamPriv.h"
#include <algorithm>
#include <cstddef>
#include <cstring>
#include <limits>
#include <new>

Go to the source code of this file.

Classes
struct	SkDynamicMemoryWStream::Block
class	SkBlockMemoryRefCnt
class	SkBlockMemoryStream

Macros
#define	SK_MAX_BYTE_FOR_U8   0xFD
#define	SK_BYTE_SENTINEL_FOR_U16   0xFE
#define	SK_BYTE_SENTINEL_FOR_U32   0xFF
#define	SkDynamicMemoryWStream_MinBlockSize   4096

Functions
static sk_sp< SkData >	newFromParams (const void *src, size_t size, bool copyData)
static void	sk_memcpy_4bytes (void *dst, const void *src, size_t size)
static sk_sp< SkData >	mmap_filename (const char path[])
sk_sp< SkData >	SkCopyStreamToData (SkStream *stream)
bool	SkStreamCopy (SkWStream *out, SkStream *input)
bool	StreamRemainingLengthIsBelow (SkStream *stream, size_t len)

Macro Definition Documentation

SK_BYTE_SENTINEL_FOR_U16

#define SK_BYTE_SENTINEL_FOR_U16   0xFE

Definition at line 49 of file SkStream.cpp.

SK_BYTE_SENTINEL_FOR_U32

#define SK_BYTE_SENTINEL_FOR_U32   0xFF

Definition at line 50 of file SkStream.cpp.

SK_MAX_BYTE_FOR_U8

#define SK_MAX_BYTE_FOR_U8   0xFD

Definition at line 48 of file SkStream.cpp.

SkDynamicMemoryWStream_MinBlockSize

#define SkDynamicMemoryWStream_MinBlockSize   4096

Definition at line 467 of file SkStream.cpp.

Function Documentation

mmap_filename()

static sk_sp< SkData > mmap_filename ( const char  path[] )

static

Definition at line 911 of file SkStream.cpp.

                                                      {
    FILE* file = sk_fopen(path, kRead_SkFILE_Flag);
    if (nullptr == file) {
        return nullptr;
    }
 
    auto data = SkData::MakeFromFILE(file);
    sk_fclose(file);
    return data;
}

newFromParams()

static sk_sp< SkData > newFromParams ( const void *  src, size_t  size, bool  copyData  )

static

Definition at line 276 of file SkStream.cpp.

                                                                                {
    if (copyData) {
        return SkData::MakeWithCopy(src, size);
    } else {
        return SkData::MakeWithoutCopy(src, size);
    }
}

sk_memcpy_4bytes()

static void sk_memcpy_4bytes ( void *  dst, const void *  src, size_t  size  )

inlinestatic

Definition at line 459 of file SkStream.cpp.

                                                                             {
    if (size == 4) {
        memcpy(dst, src, 4);
    } else {
        memcpy(dst, src, size);
    }
}

SkCopyStreamToData()

sk_sp< SkData > SkCopyStreamToData

(

SkStream *

stream

)

Copy the provided stream to an SkData variable.

Note: Assumes the stream is at the beginning. If it has a length, but is not at the beginning, this call will fail (return NULL).

Parameters

stream

SkStream to be copied into data.

Returns

The resulting SkData after the copy, nullptr on failure.

Definition at line 937 of file SkStream.cpp.

                                                   {
    SkASSERT(stream != nullptr);
 
    if (stream->hasLength()) {
        return SkData::MakeFromStream(stream, stream->getLength());
    }
 
    SkDynamicMemoryWStream tempStream;
    const size_t bufferSize = 4096;
    char buffer[bufferSize];
    do {
        size_t bytesRead = stream->read(buffer, bufferSize);
        tempStream.write(buffer, bytesRead);
    } while (!stream->isAtEnd());
    return tempStream.detachAsData();
}

SkStreamCopy()

bool SkStreamCopy	(	SkWStream *	out,
		SkStream *	input
	)

Copies the input stream from the current position to the end. Does not rewind the input stream.

Definition at line 954 of file SkStream.cpp.

                                                   {
    const char* base = static_cast<const char*>(input->getMemoryBase());
    if (base && input->hasPosition() && input->hasLength()) {
        // Shortcut that avoids the while loop.
        size_t position = input->getPosition();
        size_t length = input->getLength();
        SkASSERT(length >= position);
        return out->write(&base[position], length - position);
    }
    char scratch[4096];
    size_t count;
    while (true) {
        count = input->read(scratch, sizeof(scratch));
        if (0 == count) {
            return true;
        }
        if (!out->write(scratch, count)) {
            return false;
        }
    }
}

StreamRemainingLengthIsBelow()

bool StreamRemainingLengthIsBelow	(	SkStream *	stream,
		size_t	len
	)

Definition at line 976 of file SkStream.cpp.

                                                                {
    SkASSERT(stream);
    if (stream->hasLength()) {
        if (stream->hasPosition()) {
            size_t remainingBytes = stream->getLength() - stream->getPosition();
            return remainingBytes < len;
        }
        // We don't know the position, but we can still return true if the
        // stream's entire length is shorter than the requested length.
        return stream->getLength() < len;
    }
    return false;
}