tags:

views:

35

answers:

1

Hi! Sorry for my bad english...

So, I try to decompress 128x128 jpeg image that was created in Microsoft Paint. The image is all black.

I use xawtv sources as example to create my own jpeg to yuv decompressor (http://xawtv.sourcearchive.com/documentation/3.95.dfsg.1/conv-mjpeg_8c-source.html). Decompressor works only with 4:2:0 level of yuv subsampling.

Application throws access violation in jpeg_read_raw_data function when i is equal to 112. Can anybody help to resolve this problem?

#include <fstream>
#include <iostream>
#include <string>
#include <vector>

#include "jpeglib.h"

typedef std::vector<unsigned char> buffer;

class decompressor
{
public:

    decompressor(buffer& ibuf)
          : ibuf_(ibuf), yuvbuf_(3)
    {
        info_.err = jpeg_std_error(&e_);

        jpeg_create_decompress(&info_);

        jpeg_mem_src(&info_, &ibuf_[0], ibuf_.size());
    }

    virtual ~decompressor()
    {
        jpeg_destroy_decompress(&info_);
    }

    virtual void decompress(buffer& obuf)
    {
        jpeg_read_header(&info_, 1);

        info_.raw_data_out = 1;

        jpeg_start_decompress(&info_);

        obuf.resize(
            info_.output_width *
            info_.output_height *
            info_.output_components);

        for (std::size_t i = 0; i < yuvbuf_.size(); ++i)
        {
            yuvbuf_[i].resize(info_.output_width);
            yuvptr_[i] = &yuvbuf_[i][0];
        }

        unsigned char* row = &obuf[0];

        for (std::size_t i = 0; i < info_.output_height; ++i, row += info_.output_width)
        {
            yuvptr_[0][i] = row;
        }

        row = &obuf[0] + info_.output_width * info_.output_height;

        for (std::size_t i = 0; i < info_.output_height; i += 2, row += info_.output_width / 2)
        {
            yuvptr_[1][i / 2] = row;
        }

        row = &obuf[0] + info_.output_width * info_.output_height * 5 / 4;

        for (std::size_t i = 0; i < info_.output_height; i += 2, row += info_.output_width / 2)
        {
            yuvptr_[2][i / 2] = row;
        }

        for (std::size_t i = 0; i < info_.output_height; i += 16)
        {
            jpeg_read_raw_data(&info_, yuvptr_, 16);

            yuvptr_[0] += 16;
            yuvptr_[1] += 8;
            yuvptr_[2] += 8;
        }

        jpeg_finish_decompress(&info_);
    }

protected:

    jpeg_decompress_struct info_;

    jpeg_error_mgr e_;

    buffer& ibuf_;

    std::vector<
        std::vector<unsigned char*>
    > yuvbuf_;

    unsigned char** yuvptr_[3];
};

int main()
{
    std::string filename;

    filename = "i.jpg";

    std::fstream ifs(filename.c_str(), std::ios::in | std::ios::binary);
    if (!ifs)
    {
        std::cout << "can not open file " << filename;
        return 1;
    }

    filename = "o.dat";

    std::fstream ofs(filename.c_str(), std::ios::out | std::ios::binary);
    if (!ofs)
    {
        std::cout << "can not open file " << filename;
        return 1;
    }

    std::size_t size;

    ifs.seekg(0, std::ios::end);
    size = ifs.tellg();
    ifs.seekg(0);

    buffer ibuf(size);
    buffer obuf;

    ifs.read((char*)&ibuf[0], ibuf.size());

    decompressor d(ibuf);

    d.decompress(obuf);

    ofs.write((char*)&obuf[0], obuf.size());

    return 1;
}
A: 

I found one mistake, but output_width and output_height are both uqual to 128. So, problem isn't here...

for (std::size_t i = 0; i < yuvbuf_.size(); ++i)
{
    yuvbuf_[i].resize(info_.output_width);
    yuvptr_[i] = &yuvbuf_[i][0];
}
Sonntex