Image processing 从编码图像和视频中提取DCT系数

有没有一种方法可以轻松地从编码图像和视频中提取DCT系数（和量化参数）？任何解码器软件都必须使用它们来解码块DCT编码的图像和视频。所以我很确定解码器知道它们是什么。有没有办法让使用解码器的人知道

我正在实现一些直接在DCT域工作的视频质量评估算法。目前，我的大部分代码都使用OpenCV，因此如果有人知道使用该框架的解决方案，那就太好了。我不介意使用其他库（可能是libjpeg，但这似乎只适用于静态图像），但我主要关心的是尽可能少地做特定于格式的工作（我不想重新发明轮子并编写自己的解码器）。我希望能够打开OpenCV可以打开的任何视频/图像（H.264、MPEG、JPEG等），如果是块DCT编码的，则可以获得DCT系数

在最坏的情况下，我知道我可以编写自己的块DCT代码，通过它运行解压缩的帧/图像，然后我就会回到DCT域。这不是一个优雅的解决方案，我希望我能做得更好

目前，我使用相当常见的OpenCV样板打开图像：

IplImage *image = cvLoadImage(filename);
// Run quality assessment metric

我在视频中使用的代码同样微不足道：

CvCapture *capture = cvCaptureFromAVI(filename);    
while (cvGrabFrame(capture))
{
    IplImage *frame = cvRetrieveFrame(capture);
    // Run quality assessment metric on frame
}
cvReleaseCapture(&capture);

---

在这两种情况下，我都得到了BGR格式的3通道

IplImage

。还有什么办法可以得到DCT系数吗？

好吧，我读了一些书，我最初的问题似乎是一厢情愿

基本上，不可能从H.264视频帧中获得DCT系数，原因很简单，H.264。它使用不同的变换（整数变换）。接下来，该变换的系数不一定会逐帧改变——H.264更聪明，因为它会将帧分割成片。应该可以通过一个特殊的解码器获得这些系数，但我怀疑OpenCV是否会向用户公开这些系数

对于JPEG来说，情况更乐观一些。正如我所怀疑的，为您公开DCT系数。我写了一个小应用程序来证明它是有效的（最后是源代码）。它使用每个块的DC项生成新图像。因为DC项等于块平均值（经过适当缩放后），所以DC图像是输入JPEG图像的下采样版本

编辑：修复了源中的缩放

原始图像（512 x 512）：

DC图像（64x64）：luma Cr Cb RGB

来源（C++）：

#包括
#包括
#包括
#包括
外部“C”
{
#包括“jpeglib.h”
#包括
}
#定义调试0
#定义输出图像1
/*
*从指定组件中提取DC项。
*/
IplImage*
提取dc（解压cinfo，解压barray，解压系数，整数ci）
{
jpeg_component_info*ci_ptr=&cinfo->comp_info[ci]；
CvSize size=CvSize（ci_ptr->宽度_in_块，ci_ptr->高度_in_块）；
IplImage*dc=cvCreateImage（大小，IPL_深度_8U，1）；
断言（dc！=NULL）；
JQUANT\u TBL*TBL=ci\u ptr->quant\u table；
UINT16 dc_quant=tbl->quantval[0]；
#如果调试
printf（“DCT方法：%x\n”，cinfo->DCT\u方法）；
printf
(
“组件：%d（%d x%d个块）采样：（%d x%d）\n”，
ci，
ci_ptr->块中的宽度，
ci_ptr->高度（以块为单位），
ci_ptr->h_samp_因子，
ci_ptr->v_samp_因子
);
printf（“量化表：%d\n”，ci）；
对于（int i=0；i数量[i]）；
如果（（i+1）%8==0）
printf（“\n”）；
}
printf（“原始DC系数：\n”）；
#恩迪夫
JBLOCKARRAY buf=
（cinfo->mem->access\u virt\u barray）
(
(j_common_ptr)cinfo,，
系数[ci]，
0,
ci_ptr->v_samp_因子，
错误的
);
对于（int sf=0；（JDIMENSION）sfheight_in_blocks；++sf）
{
对于（JDIMENSION b=0；bwidth_in_blocks；++b）
{
int强度=0；
强度=buf[sf][b][0]*dc_-quant/DCTSIZE+128；
强度=最大值（0，强度）；
强度=最小值（255，强度）；
cvSet2D（dc，sf，（int）b，cvScalar（intensity））；
#如果调试
printf（“%2d”，buf[sf][b][0]）；
#恩迪夫
}
#如果调试
printf（“\n”）；
#恩迪夫
}
返回dc；
}
IplImage*高档色度（IplImage*四分之一，CvSize全尺寸）
{
IplImage*full=cvCreateImage（全尺寸，IPL深度，1）；
cvResize（四分之一、完整、CV_-INTER_-NN）；
全额退还；
}
全球（国际）
读取JPEG文件（字符*文件名，IplImage**dc）
{
/*此结构包含JPEG解压缩参数和指向的指针
*工作空间（JPEG库根据需要分配）。
*/
结构jpeg\u解压缩\u结构cinfo；
结构jpeg\u错误\u管理器jerr；
/*更多的东西*/
文件*infle；/*源文件*/
/*在本例中，我们希望在执行任何其他操作之前打开输入文件，
*因此，下面的setjmp（）错误恢复可以假定文件已打开。
*非常重要：如果您使用的机器
*需要它才能读取二进制文件。
*/
if（（infle=fopen（文件名，“rb”））==NULL）{
fprintf（stderr，“无法打开%s\n”，文件名）；
返回0；
}
/*步骤1：分配并初始化JPEG解压缩对象*/
cinfo.err=jpeg\u std\u error（&jerr）；
/*现在我们可以初始化JPEG解压缩对象*/
jpeg\u创建\u解压缩（&cinfo）；
/*步骤2：指定数据源（例如，文件）*/
jpeg_stdio_src（&cinfo，infle）；
/*步骤3：使用jpeg_read_头（）读取文件参数*/
（void）jpeg_read_头（&cinfo，TRUE）；
/*我们可以忽略jpeg_read_头的返回值，因为
*（a）stdio数据源无法暂停，以及
*（b）我们传递了TRUE，将拒绝仅表格JPEG文件作为错误。
*有关详细信息，请参阅libjpeg.txt。
*/
/*台阶
#include <stdio.h>
#include <assert.h>

#include <cv.h>    
#include <highgui.h>

extern "C"
{
#include "jpeglib.h"
#include <setjmp.h>
}

#define DEBUG 0
#define OUTPUT_IMAGES 1

/*
 * Extract the DC terms from the specified component.
 */
IplImage *
extract_dc(j_decompress_ptr cinfo, jvirt_barray_ptr *coeffs, int ci)
{
    jpeg_component_info *ci_ptr = &cinfo->comp_info[ci];
    CvSize size = cvSize(ci_ptr->width_in_blocks, ci_ptr->height_in_blocks);
    IplImage *dc = cvCreateImage(size, IPL_DEPTH_8U, 1);
    assert(dc != NULL);

    JQUANT_TBL *tbl = ci_ptr->quant_table;
    UINT16 dc_quant = tbl->quantval[0];

#if DEBUG
    printf("DCT method: %x\n", cinfo->dct_method);
    printf
    (
        "component: %d (%d x %d blocks) sampling: (%d x %d)\n", 
        ci, 
        ci_ptr->width_in_blocks, 
        ci_ptr->height_in_blocks,
        ci_ptr->h_samp_factor, 
        ci_ptr->v_samp_factor
    );

    printf("quantization table: %d\n", ci);
    for (int i = 0; i < DCTSIZE2; ++i)
    {
        printf("% 4d ", (int)(tbl->quantval[i]));
        if ((i + 1) % 8 == 0)
            printf("\n");
    }

    printf("raw DC coefficients:\n");
#endif

    JBLOCKARRAY buf =
    (cinfo->mem->access_virt_barray)
    (
        (j_common_ptr)cinfo,
        coeffs[ci],
        0,
        ci_ptr->v_samp_factor,
        FALSE
    );
    for (int sf = 0; (JDIMENSION)sf < ci_ptr->height_in_blocks; ++sf)
    {
        for (JDIMENSION b = 0; b < ci_ptr->width_in_blocks; ++b)
        {
            int intensity = 0;

            intensity = buf[sf][b][0]*dc_quant/DCTSIZE + 128;
            intensity = MAX(0,   intensity);
            intensity = MIN(255, intensity);

            cvSet2D(dc, sf, (int)b, cvScalar(intensity));

#if DEBUG
            printf("% 2d ", buf[sf][b][0]);                        
#endif
        }
#if DEBUG
        printf("\n");
#endif
    }

    return dc;

}

IplImage *upscale_chroma(IplImage *quarter, CvSize full_size)
{
    IplImage *full = cvCreateImage(full_size, IPL_DEPTH_8U, 1);
    cvResize(quarter, full, CV_INTER_NN);
    return full;
}

GLOBAL(int)
read_JPEG_file (char * filename, IplImage **dc)
{
  /* This struct contains the JPEG decompression parameters and pointers to
   * working space (which is allocated as needed by the JPEG library).
   */
  struct jpeg_decompress_struct cinfo;

  struct jpeg_error_mgr jerr;
  /* More stuff */
  FILE * infile;        /* source file */

  /* In this example we want to open the input file before doing anything else,
   * so that the setjmp() error recovery below can assume the file is open.
   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
   * requires it in order to read binary files.
   */

  if ((infile = fopen(filename, "rb")) == NULL) {
    fprintf(stderr, "can't open %s\n", filename);
    return 0;
  }

  /* Step 1: allocate and initialize JPEG decompression object */

  cinfo.err = jpeg_std_error(&jerr);

  /* Now we can initialize the JPEG decompression object. */
  jpeg_create_decompress(&cinfo);

  /* Step 2: specify data source (eg, a file) */

  jpeg_stdio_src(&cinfo, infile);

  /* Step 3: read file parameters with jpeg_read_header() */

  (void) jpeg_read_header(&cinfo, TRUE);
  /* We can ignore the return value from jpeg_read_header since
   *   (a) suspension is not possible with the stdio data source, and
   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
   * See libjpeg.txt for more info.
   */

  /* Step 4: set parameters for decompression */

  /* In this example, we don't need to change any of the defaults set by
   * jpeg_read_header(), so we do nothing here.
   */

  jvirt_barray_ptr *coeffs = jpeg_read_coefficients(&cinfo);

  IplImage *y    = extract_dc(&cinfo, coeffs, 0);
  IplImage *cb_q = extract_dc(&cinfo, coeffs, 1);
  IplImage *cr_q = extract_dc(&cinfo, coeffs, 2);

  IplImage *cb = upscale_chroma(cb_q, cvGetSize(y));
  IplImage *cr = upscale_chroma(cr_q, cvGetSize(y));

  cvReleaseImage(&cb_q);
  cvReleaseImage(&cr_q);

#if OUTPUT_IMAGES
  cvSaveImage("y.png",   y);
  cvSaveImage("cb.png", cb);
  cvSaveImage("cr.png", cr);
#endif

  *dc = cvCreateImage(cvGetSize(y), IPL_DEPTH_8U, 3);
  assert(dc != NULL);

  cvMerge(y, cr, cb, NULL, *dc);

  cvReleaseImage(&y);
  cvReleaseImage(&cb);
  cvReleaseImage(&cr);

  /* Step 7: Finish decompression */

  (void) jpeg_finish_decompress(&cinfo);
  /* We can ignore the return value since suspension is not possible
   * with the stdio data source.
   */

  /* Step 8: Release JPEG decompression object */

  /* This is an important step since it will release a good deal of memory. */
  jpeg_destroy_decompress(&cinfo);

  fclose(infile);

  return 1;
}

int 
main(int argc, char **argv)
{
    int ret = 0;
    if (argc != 2)
    {
        fprintf(stderr, "usage: %s filename.jpg\n", argv[0]);
        return 1;
    }
    IplImage *dc = NULL;
    ret = read_JPEG_file(argv[1], &dc);
    assert(dc != NULL);

    IplImage *rgb = cvCreateImage(cvGetSize(dc), IPL_DEPTH_8U, 3);
    cvCvtColor(dc, rgb, CV_YCrCb2RGB);

#if OUTPUT_IMAGES
    cvSaveImage("rgb.png", rgb);
#else
    cvNamedWindow("DC", CV_WINDOW_AUTOSIZE); 
    cvShowImage("DC", rgb);
    cvWaitKey(0);
#endif

    cvReleaseImage(&dc);
    cvReleaseImage(&rgb);

    return 0;
}

#include <iostream>
#include <stdio.h>
#include <jpeglib.h>
#include <stdlib.h>
#include <setjmp.h>
#include <fstream>

#include <QVector>

int read_jpeg_file( char *filename, QVector<QVector<int> > &dct_coeff, QVector<unsigned short> &quant_tbl)
{
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;
    FILE * infile;

    if ((infile = fopen(filename, "rb")) == NULL) {
      fprintf(stderr, "can't open %s\n", filename);
      return 0;
    }

    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_decompress(&cinfo);
    jpeg_stdio_src(&cinfo, infile);
    (void) jpeg_read_header(&cinfo, TRUE);

    jvirt_barray_ptr *coeffs_array = jpeg_read_coefficients(&cinfo);
    for (int ci = 0; ci < 1; ci++)
    {
        JBLOCKARRAY buffer_one;
        JCOEFPTR blockptr_one;
        jpeg_component_info* compptr_one;
        compptr_one = cinfo.comp_info + ci;

        for (int by = 0; by < compptr_one->height_in_blocks; by++)
        {
            buffer_one = (cinfo.mem->access_virt_barray)((j_common_ptr)&cinfo, coeffs_array[ci], by, (JDIMENSION)1, FALSE);
            for (int bx = 0; bx < compptr_one->width_in_blocks; bx++)
            {
                blockptr_one = buffer_one[0][bx];
                QVector<int> tmp;
                for (int bi = 0; bi < 64; bi++)
                {
                    tmp.append(blockptr_one[bi]);
                }
                dct_coeff.push_back(tmp);
            }
        }
    }


    // coantization table
    j_decompress_ptr dec_cinfo  = (j_decompress_ptr) &cinfo;
    jpeg_component_info *ci_ptr = &dec_cinfo->comp_info[0];
    JQUANT_TBL *tbl = ci_ptr->quant_table;

    for(int ci =0 ; ci < 64; ci++){
        quant_tbl.append(tbl->quantval[ci]);
    }

    return 1;
}

int main()
{
    QVector<QVector<int> > v;
    QVector<unsigned short> quant_tbl;
    char *infilename = "your_image.jpg";

    std::ofstream out;
    out.open("out_dct.txt");


    if( read_jpeg_file( infilename, v, quant_tbl ) > 0 ){

        for(int j = 0; j < v.size(); j++ ){
                for (int i = 0; i < v[0].size(); ++i){
                    out << v[j][i] << "\t";
            }
            out << "---------------" << std::endl;
        }

        out << "\n\n\n" << std::string(10,'-') << std::endl;
        out << "\nQauntization Table:" << std::endl;
        for(int i = 0; i < quant_tbl.size(); i++ ){
            out << quant_tbl[i] << "\t";
        }
    }
    else{
        std::cout << "Can not read, Returned With Error";
        return -1;
    }

    out.close();

return 0;
}