{

enum

{

DEFAULT_BLOCK_SIZE = (1 << 15),

huff_val_shift = 20,

huff_code_mask = (1 << huff_val_shift) - 1

};

BitStream()

{

m_buf.resize(DEFAULT_BLOCK_SIZE + 1024);

m_start = &m_buf[0];

m_end = m_start + DEFAULT_BLOCK_SIZE;

m_is_opened = false;

m_f = 0;

m_current = 0;

m_pos = 0;

}

~BitStream()

{

close();

}

bool open(const String& filename)

{

close();

m_f = fopen(filename.c_str(), "wb");

if( !m_f )

return false;

m_current = m_start;

m_pos = 0;

return true;

}

bool isOpened() const { return m_f != 0; }

void close()

{

writeBlock();

if( m_f )

fclose(m_f);

m_f = 0;

}

void writeBlock()

{

size_t wsz0 = m_current - m_start;

if( wsz0 > 0 && m_f )

{

size_t wsz = fwrite(m_start, 1, wsz0, m_f);

CV_Assert( wsz == wsz0 );

}

m_pos += wsz0;

m_current = m_start;

}

size_t getPos() const

{

return (size_t)(m_current - m_start) + m_pos;

}

void putByte(int val)

{

*m_current++ = (uchar)val;

if( m_current >= m_end )

writeBlock();

}

void putBytes(const uchar* buf, int count)

{

uchar* data = (uchar*)buf;

CV_Assert(m_f && data && m_current && count >= 0);

if( m_current >= m_end )

writeBlock();

while( count )

{

int l = (int)(m_end - m_current);

if (l > count)

l = count;

if( l > 0 )

{

memcpy(m_current, data, l);

m_current += l;

data += l;

count -= l;

}

if( m_current >= m_end )

writeBlock();

}

}

void putShort(int val)

{

m_current[0] = (uchar)val;

m_current[1] = (uchar)(val >> 8);

m_current += 2;

if( m_current >= m_end )

writeBlock();

}

void putInt(int val)

{

m_current[0] = (uchar)val;

m_current[1] = (uchar)(val >> 8);

m_current[2] = (uchar)(val >> 16);

m_current[3] = (uchar)(val >> 24);

m_current += 4;

if( m_current >= m_end )

writeBlock();

}

void jputShort(int val)

{

m_current[0] = (uchar)(val >> 8);

m_current[1] = (uchar)val;

m_current += 2;

if( m_current >= m_end )

writeBlock();

}

void patchInt(int val, size_t pos)

{

if( pos >= m_pos )

{

ptrdiff_t delta = pos - m_pos;

CV_Assert( delta < m_current - m_start );

m_start[delta] = (uchar)val;

m_start[delta+1] = (uchar)(val >> 8);

m_start[delta+2] = (uchar)(val >> 16);

m_start[delta+3] = (uchar)(val >> 24);

}

else

{

long fpos = ftell(m_f);

fseek(m_f, (long)pos, SEEK_SET);

uchar buf[] = { (uchar)val, (uchar)(val >> 8), (uchar)(val >> 16), (uchar)(val >> 24) };

fwrite(buf, 1, 4, m_f);

fseek(m_f, fpos, SEEK_SET);

}

}

void jput(unsigned currval)

{

uchar v;

uchar* ptr = m_current;

v = (uchar)(currval >> 24);

*ptr++ = v;

if( v == 255 )

*ptr++ = 0;

v = (uchar)(currval >> 16);

*ptr++ = v;

if( v == 255 )

*ptr++ = 0;

v = (uchar)(currval >> 8);

*ptr++ = v;

if( v == 255 )

*ptr++ = 0;

v = (uchar)currval;

*ptr++ = v;

if( v == 255 )

*ptr++ = 0;

m_current = ptr;

if( m_current >= m_end )

writeBlock();

}

void jflush(unsigned currval, int bitIdx)

{

uchar v;

uchar* ptr = m_current;

currval |= (1 << bitIdx)-1;

while( bitIdx < 32 )

{

v = (uchar)(currval >> 24);

*ptr++ = v;

if( v == 255 )

*ptr++ = 0;

currval <<= 8;

bitIdx += 8;

}

m_current = ptr;

if( m_current >= m_end )

writeBlock();

}

static bool createEncodeHuffmanTable( const int* src, unsigned* table, int max_size )

{

int i, k;

int min_val = INT_MAX, max_val = INT_MIN;

int size;

/* calc min and max values in the table */

for( i = 1, k = 1; src[k] >= 0; i++ )

{

int code_count = src[k++];

for( code_count += k; k < code_count; k++ )

{

int val = src[k] >> huff_val_shift;

if( val < min_val )

min_val = val;

if( val > max_val )

max_val = val;

}

}

size = max_val - min_val + 3;

if( size > max_size )

{

CV_Error(CV_StsOutOfRange, "too big maximum Huffman code size");

return false;

}

memset( table, 0, size*sizeof(table[0]));

table[0] = min_val;

table[1] = size - 2;

for( i = 1, k = 1; src[k] >= 0; i++ )

{

int code_count = src[k++];

for( code_count += k; k < code_count; k++ )

{

int val = src[k] >> huff_val_shift;

int code = src[k] & huff_code_mask;

table[val - min_val + 2] = (code << 8) | i;

}

}

return true;

}

static int* createSourceHuffmanTable(const uchar* src, int* dst,

int max_bits, int first_bits)

{

int i, val_idx, code = 0;

int* table = dst;

*dst++ = first_bits;

for (i = 1, val_idx = max_bits; i <= max_bits; i++)

{

int code_count = src[i - 1];

dst[0] = code_count;

code <<= 1;

for (int k = 0; k < code_count; k++)

{

dst[k + 1] = (src[val_idx + k] << huff_val_shift) | (code + k);

}

code += code_count;

dst += code_count + 1;

val_idx += code_count;

}

dst[0] = -1;

return table;

}

std::vector<uchar> m_buf;

uchar* m_start;

uchar* m_end;

uchar* m_current;

size_t m_pos;

bool m_is_opened;

FILE* m_f;

{

mjpeg_buffer()

{

reset();

}

void resize(int size)

{

data.resize(size);

}

void put(unsigned bits, int len)

{

if((m_pos == (data.size() - 1) && len > bits_free) || m_pos == data.size())

{

resize(int(2*data.size()));

}

bits_free -= (len);

unsigned int tempval = (bits) & bit_mask[(len)];

if( bits_free <= 0 )

{

data[m_pos] |= ((unsigned)tempval >> -bits_free);

bits_free += 32;

++m_pos;

data[m_pos] = bits_free < 32 ? (tempval << bits_free) : 0;

}

else

{

data[m_pos] |= (bits_free == 32) ? tempval : (tempval << bits_free);

}

}

void finish()

{

if(bits_free == 32)

{

bits_free = 0;

m_data_len = m_pos;

}

else

{

m_data_len = m_pos + 1;

}

}

void reset()

{

bits_free = 32;

m_pos = 0;

m_data_len = 0;

}

void clear()

{

//we need to clear only first element, the rest would be overwritten

data[0] = 0;

}

int get_bits_free()

{

return bits_free;

}

unsigned* get_data()

{

return &data[0];

}

unsigned get_len()

{

return m_data_len;

}

std::vector<unsigned> data;

int bits_free;

unsigned m_pos;

unsigned m_data_len;

{

mjpeg_buffer_keeper()

{

reset();

}

mjpeg_buffer& operator[](int i)

{

return m_buffer_list[i];

}

void allocate_buffers(int count, int size)

{

for(int i = (int)m_buffer_list.size(); i < count; ++i)

{

m_buffer_list.push_back(mjpeg_buffer());

m_buffer_list.back().resize(size);

}

}

unsigned* get_data()

{

//if there is only one buffer (single thread) there is no need to stack buffers

if(m_buffer_list.size() == 1)

{

m_buffer_list[0].finish();

m_data_len = m_buffer_list[0].get_len();

m_last_bit_len = m_buffer_list[0].get_bits_free() ? 32 - m_buffer_list[0].get_bits_free() : 0;

return m_buffer_list[0].get_data();

}

allocate_output_buffer();

int bits = 0;

unsigned currval = 0;

m_data_len = 0;

for(unsigned j = 0; j < m_buffer_list.size(); ++j)

{

mjpeg_buffer& buffer = m_buffer_list[j];

//if no bit shift required we could use memcpy

if(bits == 0)

{

size_t current_pos = m_data_len;

if(buffer.get_bits_free() == 0)

{

memcpy(&m_output_buffer[current_pos], buffer.get_data(), sizeof(buffer.get_data()[0])*buffer.get_len());

m_data_len += buffer.get_len();

currval = 0;

}

else

{

memcpy(&m_output_buffer[current_pos], buffer.get_data(), sizeof(buffer.get_data()[0])*(buffer.get_len() - 1 ));

m_data_len += buffer.get_len() - 1;

currval = buffer.get_data()[buffer.get_len() - 1];

}

}

else

{

for(unsigned i = 0; i < buffer.get_len() - 1; ++i)

{

currval |= ( (unsigned)buffer.get_data()[i] >> (31 & (-bits)) );

m_output_buffer[m_data_len++] = currval;

currval = buffer.get_data()[i] << (bits + 32);

}

currval |= ( (unsigned)buffer.get_data()[buffer.get_len() - 1] >> (31 & (-bits)) );

if( buffer.get_bits_free() <= -bits)

{

m_output_buffer[m_data_len++] = currval;

currval = buffer.get_data()[buffer.get_len() - 1] << (bits + 32);

}

}

bits += buffer.get_bits_free();

if(bits > 0)

{

bits -= 32;

}

}

//bits == 0 means that last element shouldn't be used.

m_output_buffer[m_data_len++] = currval;

m_last_bit_len = -bits;

return &m_output_buffer[0];

}

int get_last_bit_len()

{

return m_last_bit_len;

}

int get_data_size()

{

return m_data_len;

}

void reset()

{

m_last_bit_len = 0;

for(unsigned i = 0; i < m_buffer_list.size(); ++i)

{

m_buffer_list[i].reset();

}

//there is no need to erase output buffer since it would be overwritten

m_data_len = 0;

}

void allocate_output_buffer()

{

unsigned total_size = 0;

for(unsigned i = 0; i < m_buffer_list.size(); ++i)

{

m_buffer_list[i].finish();

total_size += m_buffer_list[i].get_len();

}

if(total_size > m_output_buffer.size())

{

m_output_buffer.clear();

m_output_buffer.resize(total_size);

}

}

std::deque<mjpeg_buffer> m_buffer_list;

std::vector<unsigned> m_output_buffer;

int m_data_len;

int m_last_bit_len;

{

MotionJpegWriter()

{

rawstream = false;

nstripes = -1;

height = 0;

width = 0;

moviPointer = 0;

channels = 0;

outfps = 0;

quality = 0;

}

MotionJpegWriter(const String& filename, double fps, Size size, bool iscolor)

{

rawstream = false;

open(filename, fps, size, iscolor);

nstripes = -1;

}

~MotionJpegWriter() { close(); }

void close()

{

if( !strm.isOpened() )

return;

if( !frameOffset.empty() && !rawstream )

{

endWriteChunk(); // end LIST 'movi'

writeIndex();

finishWriteAVI();

}

strm.close();

frameOffset.clear();

frameSize.clear();

AVIChunkSizeIndex.clear();

frameNumIndexes.clear();

}

bool open(const String& filename, double fps, Size size, bool iscolor)

{

close();

if( filename.empty() )

return false;

const char* ext = strrchr(filename.c_str(), '.');

if( !ext )

return false;

if( strcmp(ext, ".avi") != 0 && strcmp(ext, ".AVI") != 0 && strcmp(ext, ".Avi") != 0 )

return false;

bool ok = strm.open(filename);

if( !ok )

return false;

CV_Assert(fps >= 1);

outfps = cvRound(fps);

width = size.width;

height = size.height;

quality = 75;

rawstream = false;

channels = iscolor ? 3 : 1;

if( !rawstream )

{

startWriteAVI();

writeStreamHeader();

}

//printf("motion jpeg stream %s has been successfully opened\n", filename.c_str());

return true;

}

bool isOpened() const { return strm.isOpened(); }

void startWriteAVI()

{

startWriteChunk(fourCC('R', 'I', 'F', 'F'));

strm.putInt(fourCC('A', 'V', 'I', ' '));

startWriteChunk(fourCC('L', 'I', 'S', 'T'));

strm.putInt(fourCC('h', 'd', 'r', 'l'));

strm.putInt(fourCC('a', 'v', 'i', 'h'));

strm.putInt(AVIH_STRH_SIZE);

strm.putInt(cvRound(1e6 / outfps));

strm.putInt(MAX_BYTES_PER_SEC);

strm.putInt(0);

strm.putInt(AVI_DWFLAG);

frameNumIndexes.push_back(strm.getPos());

strm.putInt(0);

strm.putInt(0);

strm.putInt(1); // number of streams

strm.putInt(SUG_BUFFER_SIZE);

strm.putInt(width);

strm.putInt(height);

strm.putInt(0);

strm.putInt(0);

strm.putInt(0);

strm.putInt(0);

}

void writeStreamHeader()

{

// strh

startWriteChunk(fourCC('L', 'I', 'S', 'T'));

strm.putInt(fourCC('s', 't', 'r', 'l'));

strm.putInt(fourCC('s', 't', 'r', 'h'));

strm.putInt(AVIH_STRH_SIZE);

strm.putInt(fourCC('v', 'i', 'd', 's'));

strm.putInt(fourCC('M', 'J', 'P', 'G'));

strm.putInt(0);

strm.putInt(0);

strm.putInt(0);

strm.putInt(AVI_DWSCALE);

strm.putInt(outfps);

strm.putInt(0);

frameNumIndexes.push_back(strm.getPos());

strm.putInt(0);

strm.putInt(SUG_BUFFER_SIZE);

strm.putInt(AVI_DWQUALITY);

strm.putInt(0);

strm.putShort(0);

strm.putShort(0);

strm.putShort(width);

strm.putShort(height);

// strf (use the BITMAPINFOHEADER for video)

startWriteChunk(fourCC('s', 't', 'r', 'f'));

strm.putInt(STRF_SIZE);

strm.putInt(width);

strm.putInt(height);

strm.putShort(1); // planes (1 means interleaved data (after decompression))

strm.putShort(8 * channels); // bits per pixel

strm.putInt(fourCC('M', 'J', 'P', 'G'));

strm.putInt(width * height * channels);

strm.putInt(0);

strm.putInt(0);

strm.putInt(0);

strm.putInt(0);

// Must be indx chunk

endWriteChunk(); // end strf

endWriteChunk(); // end strl

// odml

startWriteChunk(fourCC('L', 'I', 'S', 'T'));

strm.putInt(fourCC('o', 'd', 'm', 'l'));

startWriteChunk(fourCC('d', 'm', 'l', 'h'));

frameNumIndexes.push_back(strm.getPos());

strm.putInt(0);

strm.putInt(0);

endWriteChunk(); // end dmlh

endWriteChunk(); // end odml

endWriteChunk(); // end hdrl

// JUNK

startWriteChunk(fourCC('J', 'U', 'N', 'K'));

size_t pos = strm.getPos();

for( ; pos < (size_t)JUNK_SEEK; pos += 4 )

strm.putInt(0);

endWriteChunk(); // end JUNK

// movi

startWriteChunk(fourCC('L', 'I', 'S', 'T'));

moviPointer = strm.getPos();

strm.putInt(fourCC('m', 'o', 'v', 'i'));

}

void startWriteChunk(int fourcc)

{

CV_Assert(fourcc != 0);

strm.putInt(fourcc);

AVIChunkSizeIndex.push_back(strm.getPos());

strm.putInt(0);

}

void endWriteChunk()

{

if( !AVIChunkSizeIndex.empty() )

{

size_t currpos = strm.getPos();

size_t pospos = AVIChunkSizeIndex.back();

AVIChunkSizeIndex.pop_back();

int chunksz = (int)(currpos - (pospos + 4));

strm.patchInt(chunksz, pospos);

}

}

void writeIndex()

{

// old style AVI index. Must be Open-DML index

startWriteChunk(fourCC('i', 'd', 'x', '1'));

int nframes = (int)frameOffset.size();

for( int i = 0; i < nframes; i++ )

{

strm.putInt(fourCC('0', '0', 'd', 'c'));

strm.putInt(AVIIF_KEYFRAME);

strm.putInt((int)frameOffset[i]);

strm.putInt((int)frameSize[i]);

}

endWriteChunk(); // End idx1

}

void finishWriteAVI()

{

int nframes = (int)frameOffset.size();

// Record frames numbers to AVI Header

while (!frameNumIndexes.empty())

{

size_t ppos = frameNumIndexes.back();

frameNumIndexes.pop_back();

strm.patchInt(nframes, ppos);

}

endWriteChunk(); // end RIFF

}

void write(InputArray _img)

{

Mat img = _img.getMat();

size_t chunkPointer = strm.getPos();

int input_channels = img.channels();

int colorspace = -1;

if( input_channels == 1 && channels == 1 )

{

CV_Assert( img.cols == width && img.rows == height );

colorspace = COLORSPACE_GRAY;

}

else if( input_channels == 4 )

{

CV_Assert( img.cols == width && img.rows == height && channels == 3 );

colorspace = COLORSPACE_RGBA;

}

else if( input_channels == 3 )

{

CV_Assert( img.cols == width && img.rows == height && channels == 3 );

colorspace = COLORSPACE_BGR;

}

else if( input_channels == 1 && channels == 3 )

{

CV_Assert( img.cols == width && img.rows == height*3 );

colorspace = COLORSPACE_YUV444P;

}

else

CV_Error(CV_StsBadArg, "Invalid combination of specified video colorspace and the input image colorspace");

if( !rawstream )

startWriteChunk(fourCC('0', '0', 'd', 'c'));

writeFrameData(img.data, (int)img.step, colorspace, input_channels);

if( !rawstream )

{

frameOffset.push_back(chunkPointer - moviPointer);

frameSize.push_back(strm.getPos() - chunkPointer - 8); // Size excludes '00dc' and size field

endWriteChunk(); // end '00dc'

}

}

double getProperty(int propId) const

{

if( propId == VIDEOWRITER_PROP_QUALITY )

return quality;

if( propId == VIDEOWRITER_PROP_FRAMEBYTES )

return frameSize.empty() ? 0. : (double)frameSize.back();

if( propId == VIDEOWRITER_PROP_NSTRIPES )

return nstripes;

return 0.;

}

bool setProperty(int propId, double value)

{

if( propId == VIDEOWRITER_PROP_QUALITY )

{

quality = value;

return true;

}

if( propId == VIDEOWRITER_PROP_NSTRIPES)

{

nstripes = value;

return true;

}

return false;

}

void writeFrameData( const uchar* data, int step, int colorspace, int input_channels );

int outfps;

int width, height, channels;

double quality;

size_t moviPointer;

std::vector<size_t> frameOffset, frameSize, AVIChunkSizeIndex, frameNumIndexes;

bool rawstream;

mjpeg_buffer_keeper buffers_list;

double nstripes;

BitStream strm;