Android 5.0推出了新的Camera API
android.hardware.camera2
就的Camera API在新的版本已经被废弃掉了。
关于Camera2如何使用，相信网上也有一大堆文章，我们这里不做讲解。
如果你按照
https://github.com/googlesamples/android-Camera2Basic
这里面的方式来拍照的话，你会发现，无论如何也得不到旧版本Camera API拍出的高质量照片了。
Size largest = Collections.max(
Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)),
new CompareSizesByArea());
mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(),
ImageFormat.JPEG, /*maxImages*/2);
这里我用的测试机是三星的s6，这台手机后置摄像头拍摄16:9的照片，最大分辨率为5312×2988，但是如果你想上面的代码所示拍出来的照片最大分辨率为3264×2448。
那怎么办呢，我去翻看了Android 6.0系统源码里的Camera app的代码，发现Google的那帮人用的格式为YUV420_888
当然还有另外一个格式:RAW_SENSOR,Google的前辈们把这种格式保存成了png
那我们想要的肯定是jpeg嘛(jpeg和png的区别自行google)
if (sCaptureImageFormat == ImageFormat.RAW_SENSOR) {
if (!RAW_DIRECTORY.exists()) {
if (!RAW_DIRECTORY.mkdirs()) {
throw new RuntimeException("Could not create RAW directory.");
}
}
File dngFile = new File(RAW_DIRECTORY, capture.session.getTitle() + ".dng");
writeDngBytesAndClose(capture.image, capture.totalCaptureResult,
mCharacteristics, dngFile);
} else {
// Since this is not an HDR+ session, we will just save the
// result.
byte[] imageBytes = acquireJpegBytesAndClose(capture.image);
saveJpegPicture(imageBytes, capture.parameters, capture.session,
capture.totalCaptureResult);
}
然后就看到了这段代码，一直向下跟踪，发现了
private static native int compressJpegFromYUV420pNative(
int width, int height,
Object yBuf, int yPStride, int yRStride,
Object cbBuf, int cbPStride, int cbRStride,
Object crBuf, int crPStride, int crRStride,
Object outBuf, int outBufCapacity,
int quality,
int cropLeft, int cropTop, int cropRight, int cropBottom,
int rot90);
看看对应的c/c++代码
#include "jpegutil.h"
......
extern "C" {
#include "jpeglib.h"
}
果然 用到了libjpeg
===== 以下内容来自http://blog.csdn.net/talkxin/article/details/50696511 ======
为何Android图片压缩效率比IOS低质量差
为什么Android的图片压缩质量要比iPhone的压缩质量差很多，这是因为Android底层犯的一个小错误：libjpeg。并且这个错误一直持续到了今天。
libjpeg是广泛使用的开源JPEG图像库（参考 http://en.wikipedia.org/wiki/Libjpeg ），安卓也依赖libjpeg来压缩图片。通过查看源码，我们会发现安卓并不是直接封装的libjpeg，而是基于了另一个叫Skia的开源项目 （http://en.wikipedia.org/wiki/Skia_Graphics_Engine）来作为的图像处理引擎。Skia是谷歌自己维 护着的一个大而全的引擎，各种图像处理功能均在其中予以实现，并且广泛的应用于谷歌自己和其它公司的产品中（如：Chrome、Firefox、 Android等）。Skia对libjpeg进行了良好的封装，基于这个引擎可以很方便为操作系统、浏览器等开发图像处理功能。 libjpeg在压缩图像时，有一个参数叫optimize_coding，关于这个参数，libjpeg.doc有如下解释：
boolean optimize_coding
TRUE causes the compressor to compute optimal Huffman coding tables
for the image. This requires an extra pass over the data and
therefore costs a good deal of space and time. The default is
FALSE, which tells the compressor to use the supplied or default
Huffman tables. In most cases optimal tables save only a few percent
of file size compared to the default tables. Note that when this is
TRUE, you need not supply Huffman tables at all, and any you do
supply will be overwritten.
这段话大概的意思就是如果设置optimize_coding为TRUE，将会使得压缩图像过程中基于图像数据计算哈弗曼表（关于图片压缩中的哈弗曼表，请自行查阅相关资料），由于这个计算会显著消耗空间和时间，默认值被设置为FALSE。
这段解释乍看起来没有任何问题，libjpeg的代码也经受了十多年的考验，健壮而高效。但很多人忽略了这一点，那就是，这段解释是十多年前写的，对于当 时的计算设备来说，空间和时间的消耗可能是显著的，但到今天，这似乎不应再是问题，相反，我们应该更多的考虑图片的品质（越来越好的显示技术）和图片的大 小（越来越依赖于云服务）。
谷歌的Skia项目工程师们最终没有设置这个参数，optimize_coding在Skia中默认的等于了FALSE，这就意味着更差的图片质量和更大的图片文件，而压缩图片过程中所耗费的时间和空间其实反而是可以忽略不计的。那么，这个参数的影响究竟会有多大呢？
经我们实测，使用相同的原始图片，分别设置optimize_coding=TRUE和FALSE进行压缩，想达到接近的图片质量（用Photoshop 放大到像素级逐块对比），FALSE时的图片大小大约是TRUE时的5-10倍。换句话说，如果我们想在FALSE和TRUE时压缩成相同大小的JPEG 图片，FALSE的品质将大大逊色于TRUE的（虽然品质很难量化，但我们不妨说成是差5-10倍）。
我们又对Android和iOS进行了对比（均使用标准的JPEG压缩方法），两个系统都没有提供设置optimize_coding的接口（通过阅读源 码，我们已经知道Android是FALSE，iOS不详），当压缩相同的原始图片时，结果也是一样，iOS完胜。想要品质接近，文件大小就会差出 5-10倍，而如果要压缩出相同大小的文件，Android的压缩品质简直就是惨不忍睹。
结果说明，苹果很清楚optimize_coding参数和哈弗曼表的意义，这里需要特别指出，苹果使用的哈弗曼表算法与libjpeg（及我们后来自行 采用的libjpeg-turbo）不同，像素级可以看出区别，苹果似乎基于libjpeg又进行了进一步的优化，压缩出来的图片细节上更柔和、更平滑。
在Android项目中如何使用libjpeg-trubo
首先你要安装ndk，如果不知道ndk是什么，建议你先从一些简单的Android知识开始补这文章可能不太适合你；
第二你要安装git(如果不会请google)
git clone git://git.linaro.org/people/tomgall/libjpeg-turbo/libjpeg-turbo.git -b linaro-android
把最新的版本克隆下来
2、编译
克隆下来的文件夹名为libjpeg-turbo，所以我们在使用NDK编译前需要将文件夹命名为JNI：
mv libjpeg-turbo jni
使用NDK编译时，这里需要注意的是APP_ABI这个参数，若需要在不同的平台下运行，则需要设置平台参数，如例所示，将编译出两个cpu平台的so库，不同的平台用逗号分隔
ndk-build APP_ABI=armeabi-v7a,armeabi
这时就可以看到在jni同目录下会生成libs与objs两个文件夹，生成的.so类库就在libs文件夹内。
====以上内容来自http://blog.csdn.net/talkxin/article/details/50696511 ========
你还需要把头文件找齐，都在我们刚刚克隆下来的代码目录里
cderror.h
cdjpeg.h
config.h
jconfig.h
jerror.h
jinclude.h
jmorecfg.h
jpeglib.h
jversion.h
好了，接下来是怎么编写c代码
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "jpeg/jpeglib.h"
#import <omp.h>
#ifdef ANDROID
#include <jni.h>
#include <android/log.h>
#define LOGE(format, ...) __android_log_print(ANDROID_LOG_ERROR, " (>_<)", format, ##__VA_ARGS__)
#define LOGI(format, ...) __android_log_print(ANDROID_LOG_INFO, "(^_^)", format, ##__VA_ARGS__)
#else
#define LOGE(format, ...) printf("(>_<) " format "\n", ##__VA_ARGS__)
#define LOGI(format, ...) printf("(^_^) " format "\n", ##__VA_ARGS__)
#endif
int write_JPEG_file(const char *filename, unsigned char *yData, unsigned char *uData,
unsigned char *vData, int quality, int image_width, int image_height);
void Java_${这里替换成类的全路径}_writeJpegFile(JNIEnv *env, jobject jobj,
jstring fileName,
jobject yBuffer,
jint yLen,
jobject cbBuffer,
jint cbLen,
jobject crBuffer,
jint uvStride,
jint quality,
jint width, jint height) {
char *filename[500] = {0};
sprintf(filename, "%s", (*env)->GetStringUTFChars(env, fileName, NULL));
jbyte *y = (*env)->GetDirectBufferAddress(env, yBuffer);
jbyte *cb = (*env)->GetDirectBufferAddress(env, cbBuffer);
jbyte *cr = (*env)->GetDirectBufferAddress(env, crBuffer);
uint8_t *uData = malloc(cbLen);
uint8_t *vData = malloc(cbLen);
int j, k;
int uLimit = 0;
int vLimit = 0;
if (uvStride == 2) { // yuv420 sp uv交错
#pragma omp parallel for num_threads(4)
for (j = 0; j < cbLen; j++) {
if (j % 2 == 0) {
uData[uLimit++] = cb[j];
} else {
vData[vLimit++] = cb[j];
}
}
#pragma omp parallel for num_threads(4)
for (k = 0; k < cbLen; k++) {
if (k % 2 == 0) {
uData[uLimit++] = cr[k];
} else {
vData[vLimit++] = cr[k];
}
}
write_JPEG_file(filename, y, uData, vData, quality, width, height);
} else { // yuv420p
write_JPEG_file(filename, y, cb, cr, quality, width, height);
}
free(uData);
free(vData);
}
int write_JPEG_file(const char *filename, unsigned char *yData, unsigned char *uData,
unsigned char *vData, int quality, int image_width, int image_height) {
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
FILE *outfile;
JSAMPIMAGE buffer;
unsigned char *pSrc, *pDst;
int band, i, buf_width[3], buf_height[3];
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
if ((outfile = fopen(filename, "wb")) == NULL) {
return -1;
}
jpeg_stdio_dest(&cinfo, outfile);
cinfo.image_width = image_width; // image width and height, in pixels
cinfo.image_height = image_height;
cinfo.input_components = 3; // # of color components per pixel
cinfo.in_color_space = JCS_RGB; //colorspace of input image
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo, quality, TRUE);
cinfo.raw_data_in = TRUE;
cinfo.jpeg_color_space = JCS_YCbCr;
cinfo.comp_info[0].h_samp_factor = 2;
cinfo.comp_info[0].v_samp_factor = 2;
jpeg_start_compress(&cinfo, TRUE);
buffer = (JSAMPIMAGE) (*cinfo.mem->alloc_small)((j_common_ptr) &cinfo,
JPOOL_IMAGE, 3 * sizeof(JSAMPARRAY));
#pragma omp parallel for num_threads(4)
for (band = 0; band < 3; band++) {
buf_width[band] = cinfo.comp_info[band].width_in_blocks * DCTSIZE;
buf_height[band] = cinfo.comp_info[band].v_samp_factor * DCTSIZE;
buffer[band] = (*cinfo.mem->alloc_sarray)((j_common_ptr) &cinfo,
JPOOL_IMAGE, buf_width[band], buf_height[band]);
}
unsigned char *rawData[3];
rawData[0] = yData;
rawData[1] = uData;
rawData[2] = vData;
int src_width[3], src_height[3];
#pragma omp parallel for num_threads(4)
for (i = 0; i < 3; i++) {
src_width[i] = (i == 0) ? image_width : image_width / 2;
src_height[i] = (i == 0) ? image_height : image_height / 2;
}
int max_line = cinfo.max_v_samp_factor * DCTSIZE;
int counter;
#pragma omp parallel for num_threads(4)
for (counter = 0; cinfo.next_scanline < cinfo.image_height; counter++) {
//buffer image copy.
#pragma omp parallel for num_threads(4)
for (band = 0; band < 3; band++) { //每个分量分别处理
int mem_size = src_width[band];//buf_width[band];
pDst = (unsigned char *) buffer[band][0];
pSrc = (unsigned char *) rawData[band] + counter * buf_height[band] *
src_width[band];//buf_width[band]; //yuv.data[band]分别表示YUV起始地址
#pragma omp parallel for num_threads(4)
for (i = 0; i < buf_height[band]; i++) { //处理每行数据
memcpy(pDst, pSrc, mem_size);
pSrc += src_width[band];//buf_width[band];
pDst += buf_width[band];
}
}
jpeg_write_raw_data(&cinfo, buffer, max_line);
}
jpeg_finish_compress(&cinfo);
fclose(outfile);
jpeg_destroy_compress(&cinfo);
return 0;
}
这里面用到了openMP对for循环进行并线处理，感兴趣的同学可以去google一下，这里只简单介绍一下怎么用
首先要加入头文件
#include<omp.h>
然后你可能会惊恐的发现AndroidStudio找不到这个东西(用eclipse的…祝你好运吧) ，别急。打开module里的 build.gradle文件加上
cmake {
arguments "-DANDROID_TOOLCHAIN=gcc"
...
cFlags="-fopenmp"
}
然后在for循环前加上这句
#pragma omp parallel for num_threads(4)
可以按需求指定并发数量
好了，写到这里收笔。再逼逼我怕各位看客们烦😒
