nv-tegra-mirror/v4l2_libs
1
0
Fork 0
mirror of git://nv-tegra.nvidia.com/tegra/v4l2-src/v4l2_libs.git synced 2025-12-22 09:21:28 +03:00
Code Issues Packages Projects Releases Wiki Activity

Updating prebuilts and/or headers

Browse Source 
f07563fa1628a75c578152387638b1f217f730be - libv4lconvert/Makefile
6ac3c887c56c7d4345499cb5b7bfac9579a57d16 - libv4lconvert/cpia1.c
2d385802ec3690e78a961ce95431e98eb3f5fc6a - libv4lconvert/rgbyuv.c
43843cbdb81f3efee5873f5ed25ae1eb7745a9e5 - libv4lconvert/libv4lconvert-priv.h
002783c808dc565478c18bd27373792028264bb6 - libv4lconvert/ov518-decomp.c
4d49e6e897046e66e41c3563fec2eb2562abf813 - libv4lconvert/jpeg_memsrcdest.c
a38fdb4c79518e972678745c93cd62881d72972b - libv4lconvert/Makefile.dGPU
e9f783fb933606224252dfd3093afa36490f6f4c - libv4lconvert/Makefile.in
52900601a24ee9ffea87ca7fe6651e912e20235e - libv4lconvert/libv4lsyscall-priv.h
d37f854500cbd759ad93ae89c6aa75c00b000931 - libv4lconvert/bayer.c
2cd1b994bb7999d0c08c19b1a2efd11707250852 - libv4lconvert/helper.c
adac14b8826d05ddab33d595a803e92eaf84b797 - libv4lconvert/Makefile.am
6e806290f6e426c881322d362f189fa7b9e2f917 - libv4lconvert/sn9c10x.c
ba44b6ac00a643e6df484f3172022e1b2628c0cc - libv4lconvert/jpgl.c
fa06343de31dcf6d3d5862cc278396272fa838c4 - libv4lconvert/se401.c
4bd081bf25b63f5463d582ef36f77ba5e3711d0d - libv4lconvert/sq905c.c
940250beb5898bf254e7cd1ef9d7950a8db10af6 - libv4lconvert/mr97310a.c
5e177c3a7c157c25c4afcae031e79830237510f6 - libv4lconvert/libv4lconvert.c
1f362080c319355070cf409cfccf28d8c68d024e - libv4lconvert/sn9c2028-decomp.c
703ce22dc98d834490c7aa23ae73b9113e386221 - libv4lconvert/sn9c20x.c
018e503969b2e06a0ea639fc08f03a7476cc15b5 - libv4lconvert/jpeg_memsrcdest.h
fb3344cfa8df97688332ee4fd3b17968437e8ad5 - libv4lconvert/helper-funcs.h
d378cbdd377027e7528af47362a94ccb1ae15da3 - libv4lconvert/libv4lconvert.export
61710972d4e9bfcd00490c563d1bb5bde5480c9e - libv4lconvert/tinyjpeg.c
231571db9f8caa6fdc68138102029127a6b93812 - libv4lconvert/crop.c
d62448a06539ecf6e3daae7faa299b6da8878054 - libv4lconvert/pac207.c
72b65c9f0f3c87dcae86a2afbea65a76f2c6bafd - libv4lconvert/tinyjpeg-internal.h
a016f896e0e9f0cd8af7447b52651ed14c5a5b29 - libv4lconvert/jpeg.c
608a4c341a5df9daea647fbddc415cdaf27b0482 - libv4lconvert/spca561-decompress.c
b03b32eae024bf59b6ceaf6b6d342383cd0b0673 - libv4lconvert/jl2005bcd.c
803c4d0b9364050eda163452b8792e62e221ab6d - libv4lconvert/tinyjpeg.h
2df34af8f9d747fb0e5c7c71954c788aff1c483f - libv4lconvert/stv0680.c
3e8e6c1fb85e3c4b58c4e9b2b0a223ddc793edcb - libv4lconvert/libv4lconvert.pc.in
02aa2e7d12b72fe4ce79cdf4009da61f35091e94 - libv4lconvert/flip.c
05038ef9efab175322a12d3d6620dba6298aa2a9 - libv4lconvert/spca501.c
b2c19c2eac71d39d3fb883cdc159a69c2afa8fd6 - libv4lconvert/ov511-decomp.c
1d9c446cd8a232da87bd79acebc93e018ec72499 - libv4lconvert/jidctflt.c
ed215eca170d07a6838be3796aad933adf89ece2 - libv4lconvert/hm12.c
193e9d2c997e21ce8ca02f25050fb8d2d62b6bfd - libv4lconvert/processing/autogain.c
c894d4a9b9e0f95be9e7bade4f7f734ae0c6996c - libv4lconvert/processing/libv4lprocessing.c
4158e9c3d21cf0a064b99bdf8571df4f3ba6d5bb - libv4lconvert/processing/whitebalance.c
be34baf0d2ce1374c841494ba27ccc352c444e98 - libv4lconvert/processing/gamma.c
b48edcb4036ee5f4e77e9cb49dd1b52b1e7f2427 - libv4lconvert/processing/libv4lprocessing.h
967d27c0e09849338a69dc4b5647d1824f2cd2fb - libv4lconvert/processing/libv4lprocessing-priv.h
9f382ff1f2895b926f3596e0a8ae7637b5e6a2ac - libv4lconvert/control/libv4lcontrol.c
8c523bd3838004a4fa00430a38cbc6dbaa47286f - libv4lconvert/control/libv4lcontrol.h
4ce5e891af7857a3504d1350ef13015997dde62a - libv4lconvert/control/libv4lcontrol-priv.h
bda0c1296aad2b3b178a76f38e26c20ce3b81233 - include/libv4l1.h
a95818658d95c1602f2422e5f1fb54b9ca70536e - include/libv4l2rds.h
2d1932763a064ef1176450b1bb4dd242aa3c77bb - include/libv4lconvert.h
3517bc15e30852ad01ad9966ec7111a16a2263df - include/libv4l2.h
944cd9bc32420e73da3a7d3cb1d0ce707263c9f0 - include/libv4l1-videodev.h
7d9d199f4e6f4ba6f0d669ee5decd74355507137 - include/libv4l-plugin.h
cfeaf0c16571e0c64bce50bcb8a6cd8d8c976187 - include/config.h
d7d4fd219e36edadc17837bff78eb8323e2a115e - include/libdvbv5/libdvb-version.h
33071176eda60242f39927e572ac6b1c1bab32e2 - include/libdvbv5/desc_event_extended.h
29c2cd2554e4f4285ab8709e6eace38046d8ecdc - include/libdvbv5/desc_t2_delivery.h
b42819db457bc6a23324faf259c0db1104741d99 - include/libdvbv5/dvb-scan.h
bae10c2fa28bb522e9fc0bb5e4b0128ab6f90e65 - include/libdvbv5/desc_partial_reception.h
f797ddac8e1adc6b29750f076df0f3a23cf630eb - include/libdvbv5/dvb-v5-std.h
48079dcae511070a8eeb55b004bd8ac06735ecc7 - include/libdvbv5/desc_ca.h
f4eb8b615b7c5a245c76e3f448e6cd848d8cf765 - include/libdvbv5/desc_cable_delivery.h
170a50b570691975e0ff22faffeb0131fc47c7c8 - include/libdvbv5/desc_logical_channel.h
c8f11e89456fc078c607d424e887babe72cd3684 - include/libdvbv5/nit.h
d39a24d0d0a0fbe732881dd2734b10d842d88de9 - include/libdvbv5/header.h
badc03677ddbcfa1d1188ddaaa4c272fccfe4a21 - include/libdvbv5/desc_atsc_service_location.h
d3bad046037cad4a95778555021a1a1a6b3040d9 - include/libdvbv5/cat.h
a614739513f62affb1059df81c064203d9fe2fcd - include/libdvbv5/desc_ca_identifier.h
6d70f699eb912c974dc06a19f9bdcb7dd0c27932 - include/libdvbv5/desc_service.h
0eda1161b34ca39b8528bc53d05fb0fc7d457f80 - include/libdvbv5/desc_frequency_list.h
22f6b663d50de467539201ecfdb363e9252c88bd - include/libdvbv5/atsc_eit.h
1c1292f060664abf6c12273a41b2bf6f704dd19b - include/libdvbv5/desc_sat.h
22de6de5e65530aa1ab38a2373db128e81983a4c - include/libdvbv5/desc_network_name.h
91178a5945e63c81051b57b7b2842139947a3b39 - include/libdvbv5/desc_extension.h
9ca776ad159cf84b2f68101bf279472741829047 - include/libdvbv5/descriptors.h
fa7e8d5e996310e1dd47d5467780d533c8a93ad8 - include/libdvbv5/dvb-dev.h
fed6115825c5b23e1e31ff80aab997f0a7b6c3fc - include/libdvbv5/sdt.h
4b892acd2ce77c060b50cf67f5faf9dc9b76edbb - include/libdvbv5/dvb-frontend.h
8b9f9e00f7bcdce58aef1d8d7234567af82e49b8 - include/libdvbv5/dvb-file.h
b8a077b8e3c6e337223fc37685d217a81df112f1 - include/libdvbv5/dvb-demux.h
01a0afbe1a4f41cf58f9ce47d65b31e3df7c8680 - include/libdvbv5/pat.h
4a49c8b46947be16356d6355aa36d72d7baa946c - include/libdvbv5/vct.h
c83200debc98ff8fa82030d36371a2caa230281a - include/libdvbv5/desc_language.h
21cea15c5d4faff2726f18bdf5b83e2210d472c4 - include/libdvbv5/mpeg_pes.h
825f75350da9fb148acc7d36af513da977105169 - include/libdvbv5/desc_isdbt_delivery.h
8f60bf43907b1eac3c1c2f031cf68a9bdebb3662 - include/libdvbv5/desc_ts_info.h
89cbb75f3e0952e4dfb145fdea776b45e05b7e76 - include/libdvbv5/desc_hierarchy.h
5c80a7ee23d1da2c91f60e79f7292248694b4f65 - include/libdvbv5/crc32.h
93b7b27ccc89e1ad4279eb12560e1dfc3d2ff1eb - include/libdvbv5/dvb-fe.h
aeeb75989de4b2ecafa1b2fc5ed30787999eec1b - include/libdvbv5/mpeg_es.h
dc684983365ffef353993faad0b105bcb87f4218 - include/libdvbv5/desc_event_short.h
5e3be50d1292109d59c80f920ba1b7a4bcbbdf56 - include/libdvbv5/eit.h
f95a0206952db4cce561455accad66a37f9a4104 - include/libdvbv5/mgt.h
88f8c78bbaf22b345e2ccb68e9b787e649dac2c1 - include/libdvbv5/libdvb-version.h.in
74a66644980a66adeba21ecc40ebefa2b4480e25 - include/libdvbv5/pmt.h
7671f125c6f61eef85f55eb314097435b3772431 - include/libdvbv5/dvb-sat.h
26fd40a10548cdb9bd4aafdda4486f9d39fd5c9e - include/libdvbv5/countries.h
65db3beaf2ec19a43a870b2759e6aecb15a95c7b - include/libdvbv5/atsc_header.h
149f7eb3c71b8f65127d3c4f2143080b115697e5 - include/libdvbv5/desc_terrestrial_delivery.h
708af2b77b2c94ee9cf593b31e20471c80ea556b - include/libdvbv5/mpeg_ts.h
ba205468e43ca16edf1ebec59dce9822044c1064 - include/libdvbv5/desc_registration_id.h
e70b24d8d1f3a248735c2d724d3b92c49b7aaba5 - include/libdvbv5/dvb-log.h
2d0557eadd4cff02ab52e26778d35b6c34f09158 - libv4l2/libv4l2-priv.h
487af43db163be6d3604371b9a504c1df2a9bf6c - libv4l2/v4l2-plugin-android.c
0ac38b46fa1659db4c05660205f212389295e7ff - libv4l2/Makefile
8ac3789333a6cd18e7f35d3b66a8a4d0293feb78 - libv4l2/Makefile.dGPU
fdd6e5e27aa8b41d5da77cb3b9be3fc3b8a44763 - libv4l2/libv4l2.export
1d37e5ea9231e7e0eea7d1a02938c6d1ae8ba791 - libv4l2/Makefile.in
51892a60925c37c865fe6eb9c923a552df180ebf - libv4l2/v4l2-plugin.c
d4c7daee644a35244ac8a5e1009a3aeb1d4fd3da - libv4l2/Makefile.am
87856c7113d150dceb254b5d548f942e7fcaf8f1 - libv4l2/libv4l2.c
d11ec5b8ce8390a72fd61457d7b8667378311191 - libv4l2/log.c
cbcee4426c19c168c6f49d04af3a0b2e30c0b681 - libv4l2/libv4l2.pc.in
55bb16d05817a3ecf076174175b2ca5b56e729d8 - libv4l2/v4l2convert.c

Change-Id: I4dd528ac6ac1e89b1e1ebadc7fdaf45cea9dcc98
This commit is contained in:
svcmobrel-release
2025-08-25 10:24:17 -07:00
parent e003da6fcd
commit 1f9ef4be87
117 changed files with 35073 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

728
libv4lconvert/jpgl.c Normal file
View File

@@ -0,0 +1,728 @@
/*
* Implementation of JPEG Lite decoding algorithm
*
* Author & Copyright (c) 2003 : Sylvain Munaut <nw8xx ]at[ 246tNt.com>
*
* v4l library adaptation: Jean-François Moine <moinejf@free.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
* Note this code was originally licensed under the GNU GPL instead of the
* GNU LGPL, its license has been changed with permission, see the permission
* mail at the end of this file.
*/
/* Original WebSite: nw802.sourceforge.net */
#include <stdlib.h>
#include "libv4lconvert-priv.h"
#define RING_QUEUE_ADVANCE_INDEX(rq,ind,n) (rq)->ind = ((rq)->ind + (n))
#define RING_QUEUE_DEQUEUE_BYTES(rq,n) RING_QUEUE_ADVANCE_INDEX(rq,ri,n)
#define RING_QUEUE_PEEK(rq,ofs) ((rq)->queue[((ofs) + (rq)->ri)])
struct RingQueue {
const unsigned char *queue;
int length;
int ri;
};
/* ============================================================================
* RingQueue bit reader
* ============================================================================
* All what is needed to read bit by nit from the RingQueue pump
* provided by usbvideo
* Critical part are macro and not functions to speed things up
* Rem: Data are read from the RingQueue as if they were 16bits Little Endian
* words. Most Significants Bits are outputed first.
*/
/* Structure used to store what we need. */
/* (We may need multiple simultaneous instance from several cam) */
struct rqBitReader {
int cur_bit;
unsigned int cur_data;
struct RingQueue *rq;
};
static inline void rqBR_init( struct rqBitReader *br, struct RingQueue *rq )
{
br->cur_bit = 16;
br->cur_data =
RING_QUEUE_PEEK( rq, 2 ) |
RING_QUEUE_PEEK( rq, 3 ) << 8 |
RING_QUEUE_PEEK( rq, 0 ) << 16 |
RING_QUEUE_PEEK( rq, 1 ) << 24 ;
RING_QUEUE_DEQUEUE_BYTES( rq, 2 );
br->rq = rq;
}
#define rqBR_peekBits(br,n) ( br->cur_data >> (32-n) )
#define rqBR_flushBits(br,n) do { \
br->cur_data <<= n; \
if ( (br->cur_bit -= n) <= 0 ) { \
br->cur_data |= \
RING_QUEUE_PEEK( br->rq, 2 ) << -br->cur_bit | \
RING_QUEUE_PEEK( br->rq, 3 ) << (8 - br->cur_bit); \
RING_QUEUE_DEQUEUE_BYTES( br->rq, 2 ); \
br->cur_bit += 16; \
} \
} while (0)
/* ============================================================================
* Real JPEG Lite stuff
* ============================================================================
*
* Precomputed tables
* Theses are computed at init time to make real-time operations faster.
* It takes some space ( about 9k ). But believe me it worth it !
*/
/* Variable Lenght Coding related tables, used for AC coefficient decoding
* TODO Check that 7 bits is enough ! */
static signed char vlcTbl_len[1<<10]; /* Meaningful bit count */
static signed char vlcTbl_run[1<<10]; /* Run */
static signed char vlcTbl_amp[1<<10]; /* Amplitude (without the sign) */
/* YUV->RGB conversion table */
static int yuvTbl_y[256];
static int yuvTbl_u1[256];
static int yuvTbl_u2[256];
static int yuvTbl_v1[256];
static int yuvTbl_v2[256];
/* Clamping table */
#define SAFE_CLAMP
#ifdef SAFE_CLAMP
static inline unsigned char clamp(int x) {
if (x > 255)
return 255;
if (x < 0)
return 0;
return x;
}
#define clamp_adjust(x) clamp(x+128)
#else
#define clamp(x) clampTbl[(x)+512]
#define clamp_adjust(x) clampTbl[(x)+640]
static char clampTbl[1280];
#endif
/* Code to initialize those tables */
static void vlcTbl_init(void)
{
/* Bases tables used to compute the bigger one
* To understands theses, look at the VLC doc in the
* US patent document. */
static const int vlc_num = 28;
static const int vlc_len[] =
{ 2, 2, 3, 3, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 7,
8 ,8 ,8 ,9, 9, 9, 10, 10, 10, 10, 10, 10 };
static const int vlc_run[] =
{ 0, 0, 0, 1, 0, 2, 3, 1, 0, 4, 0, 5, 1, 0, -1, -2,
2, 6, 0, 3, 1, 0, 1, 0, 7, 2, 0, 8 };
static const int vlc_amp[] =
{ 0, 1, 2, 1, 3, 1, 1, 2, 4, 1 ,5 ,1 ,3 ,6, -1, -2,
2, 1, 7, 2, 4, 8, 5, 9, 1 ,3, 10, 1 };
static const int vlc_cod[] =
{ 0x000, 0x002, 0x003, 0x006, 0x00E, 0x008, 0x00B, 0x012,
0x014, 0x03D, 0x03E, 0x078, 0x079, 0x07E, 0x026, 0x027,
0x054, 0x057, 0x0FF, 0x0AA, 0x0AC, 0x1FC, 0x156, 0x157,
0x15A, 0x15B, 0x3FA, 0x3FB };
/* Vars */
int i,j;
/* Main filling loop */
for ( i=0 ; i<(1<<10) ; i++ ) {
/* Find the matching one */
for ( j=0 ; j<vlc_num ; j++ ) {
if ( (i >> (10-vlc_len[j])) == vlc_cod[j] ) {
if ( vlc_run[j] >= 0 )
if ( vlc_amp[j] != 0 )
vlcTbl_len[i] = vlc_len[j] + 1;
else
vlcTbl_len[i] = vlc_len[j]; /* EOB */
else
vlcTbl_len[i] = 16;
vlcTbl_run[i] = vlc_run[j];
vlcTbl_amp[i] = vlc_amp[j];
break;
}
}
}
}
static void yuvTbl_init(void)
{
/* These tables are just pre-multiplied and pre-offseted
* YUV by the book
* R = 1.164 * (Y-16) + 1.596 * (U-128)
* G = 1.164 * (Y-16) - 0.813 * (U-128) - 0.391 * (V-128)
* B = 1.164 * (Y-16) + 2.018 * (V-128) */
int i;
/* We use fixed point << 16 */
for ( i=0 ; i < 256 ; i++ ) {
yuvTbl_y[i] = 76284 * (i- 16);
yuvTbl_u1[i] = 104595 * (i-128);
yuvTbl_u2[i] = 53281 * (i-128);
yuvTbl_v1[i] = 25625 * (i-128);
yuvTbl_v2[i] = 132252 * (i-128);
}
}
#ifndef SAFE_CLAMP
static void clampTbl_init(void)
{
/* Instead of doing if(...) to test for overrange, we use
* a clamping table */
int i;
for (i=0 ; i < 512 ; i++)
clampTbl[i] = 0;
for (i=512 ; i < 768 ; i++ )
clampTbl[i] = i - 512;
for (i=768 ; i < 1280 ; i++ )
clampTbl[i] = 255;
}
#endif
/*
* Internal helpers
*/
static inline int readAC( struct rqBitReader *br, int *run, int *amp )
{
/* Vars */
unsigned int cod;
/* Get 16 bits */
cod = rqBR_peekBits(br,16);
/* Lookup in the table */
*run = vlcTbl_run[cod>>6];
*amp = vlcTbl_amp[cod>>6];
rqBR_flushBits(br,vlcTbl_len[cod>>6]);
if (*amp > 0) {
/* Normal stuff, just correct the sign */
if (cod & (0x10000 >> vlcTbl_len[cod>>6]))
*amp = - *amp;
} else {
/* Handle special cases */
if (!*amp)
return 0;
if (*amp == -1) {
/* 0100110srrraaaaa */
*run = ( cod >> 5 ) & 0x07;
*amp = ( cod & 0x100) ?
-(cod&0x1F) : (cod&0x1F);
} else {
/* 0100111srrrraaaa */
*run = ( cod >> 4 ) & 0x0F;
*amp = ( cod & 0x100) ?
-(cod&0x0F) : (cod&0x0F);
}
}
return 1;
}
#define iDCT_column(b0,b1,b2,b3) do { \
int t0,t1,t2,t3; \
\
t0 = ( b1 + b3 ) << 5; \
t2 = t0 - (b3 << 4); \
t3 = (b1 * 47) - t0; \
t0 = b0 + b2; \
t1 = b0 - b2; \
\
b0 = ( t0 + t2 ); \
b1 = ( t1 + t3 ); \
b3 = ( t0 - t2 ); \
b2 = ( t1 - t3 ); \
} while (0)
#define iDCT_line(b0,b1,b2,b3) do { \
int t0,t1,t2,t3,bm0,bm2; \
\
bm0 = b0 << 7; \
bm2 = b2 << 7; \
\
t0 = bm0 + bm2; \
t1 = bm0 - bm2; \
t2 = b1 * 183 + b3 * 86; \
t3 = b1 * 86 - b3 * 183; \
\
b0 = ( t0 + t2 ) >> 22; \
b1 = ( t1 + t3 ) >> 22; \
b3 = ( t0 - t2 ) >> 22; \
b2 = ( t1 - t3 ) >> 22; \
} while (0)
/* Decode a block
* Basic ops : get the DC - get the ACs - deZigZag - deWeighting -
* deQuantization - iDCT
* Here they are a little mixed-up to speed all this up.
*/
static inline int decodeBlock( struct rqBitReader *br, int *block, int *dc )
{
/* Tables used for block decoding */
/* deZigZag table
*
* ZigZag: each of the coefficient of the DCT transformed 4x4
* matrix is taken in a certain order to make a linear
* array with the high frequency AC at the end
*
* / 0 1 5 6 \ .
* | 2 4 7 12 | This is the order taken. We must deZigZag
* | 3 8 11 13 | to reconstitute the original matrix
* \ 9 10 14 15 /
*/
static const int iZigZagTbl[16] =
{ 0, 1, 4, 8, 5, 2, 3, 6, 9,12, 13, 10, 7, 11, 14, 15 };
/* deQuantization, deWeighting & iDCT premultiply */
/*
* Weighting : Each DCT coefficient is weighted by a certain factor. We
* must compensate for this to rebuilt the original DCT matrix.
*
* Quantization: According to the read Q factor, DCT coefficient are
* quantized. We need to compensate for this.
*
* iDCT premultiply: Since for the first iDCT pass ( column ), we'll need
* to do some multiplication, the ones that we can
* integrate here, we do.
*
* Rem: - The factors are here presented in the ZigZaged order,
* because we will need those BEFORE the deZigZag
* - For more informations, consult jpgl_tbl.c, it's the little
* prog that computes this table
*/
static const int iQWTbl[4][16] = {
{ 32768, 17808, 794, 18618, 850, 18618, 43115, 1828,
40960, 1924, 2089, 45511, 2089, 49648, 2216, 2521 },
{ 32768, 35617, 1589, 37236, 1700, 37236, 86231, 3656,
81920, 3849, 4179, 91022, 4179, 99296, 4432, 5043 },
{ 32768, 71234, 3179, 74472, 3401, 74472, 172463, 7313,
163840, 7698, 8358, 182044, 8358, 198593, 8865, 10087 },
{ 32768, 142469, 6359, 148945, 6803, 148945, 344926, 14627,
327680, 15397, 16716, 364088, 16716, 397187, 17730, 20175 }
};
/* Vars */
int hdr;
int *eff_iQWTbl;
int cc, run, amp;
/* Read & Decode the block header ( Q, T, DC ) */
hdr = rqBR_peekBits(br,11);
if (hdr & 0x100) {
/* Differential mode */
if (hdr & 0x80)
*dc += ( hdr >> 3 ) | ~0xF;
else
*dc += ( hdr >> 3 ) & 0xF;
/* Flush the header bits */
rqBR_flushBits(br,8);
} else {
/* Direct mode */
if ( hdr & 0x80 )
*dc = hdr | ~0x7F;
else
*dc = hdr & 0x7F;
/* Flush the header bits */
rqBR_flushBits(br,11);
}
/* Clear the block & store DC ( with pre-multiply ) */
block[0] = *dc << 15;
block[1] = 0x00;
block[2] = 0x00;
block[3] = 0x00;
block[4] = 0x00;
block[5] = 0x00;
block[6] = 0x00;
block[7] = 0x00;
block[8] = 0x00;
block[9] = 0x00;
block[10] = 0x00;
block[11] = 0x00;
block[12] = 0x00;
block[13] = 0x00;
block[14] = 0x00;
block[15] = 0x00;
/* Read the AC coefficients
* at the same time, deZigZag, deQuantization, deWeighting & iDCT premultiply
*/
eff_iQWTbl = (int*) iQWTbl[hdr>>9];
cc = 0;
while ( readAC(br,&run,&amp) ) {
cc += run + 1;
if ( cc > 15 )
return -1;
block[iZigZagTbl[cc]] = amp * eff_iQWTbl[cc];
}
/* Do the column iDCT ( what's left to do ) */
iDCT_column(block[0], block[4], block[8], block[12]);
iDCT_column(block[1], block[5], block[9], block[13]);
iDCT_column(block[2], block[6], block[10], block[14]);
iDCT_column(block[3], block[7], block[11], block[15]);
/* Do the line iDCT ( complete one here ) */
iDCT_line(block[0], block[1], block[2], block[3]);
iDCT_line(block[4], block[5], block[6], block[7]);
iDCT_line(block[8], block[9], block[10], block[11]);
iDCT_line(block[12], block[13], block[14], block[15]);
return !(hdr & 0x700);
}
int v4lconvert_decode_jpgl(const unsigned char *inp, int src_size,
unsigned int dest_pix_fmt, unsigned char *fb,
int img_width, int img_height)
{
/* Vars */
struct RingQueue rq;
struct rqBitReader br;
int row, col; /* Row & Column in the image */
int x,y;
int block_idx;
unsigned char *Yline_baseptr, *Uline_baseptr, *Vline_baseptr;
unsigned char *Yline, *Uline, *Vline;
int Yline_baseofs, UVline_baseofs;
int dc_y, dc_u, dc_v; /* DC Coefficients */
int block_y[16*4]; /* Y blocks */
int block_u[16]; /* U block */
int block_v[16]; /* V block */
unsigned char *mainbuffer;
int yc,uc,vc;
/* init the decoder */
if (yuvTbl_y[0] == 0) {
vlcTbl_init();
yuvTbl_init();
#ifndef SAFE_CLAMP
clampTbl_init();
#endif
}
img_height /= 4;
/* Prepare a bit-by-bit reader */
rq.queue = inp;
rq.length = src_size;
rq.ri = 0;
rqBR_init(&br, &rq);
/* Allocate a big buffer & setup pointers */
switch (dest_pix_fmt) {
default:
/* case V4L2_PIX_FMT_RGB24: */
/* case V4L2_PIX_FMT_BGR24: */
mainbuffer = malloc(4 * (img_width + (img_width >> 1) + 2));
Yline_baseptr = mainbuffer;
Uline_baseptr = mainbuffer + (4 * img_width);
Vline_baseptr = Uline_baseptr + (img_width + 4);
break;
case V4L2_PIX_FMT_YUV420:
mainbuffer = NULL;
Yline_baseptr = fb;
Uline_baseptr = fb + img_width * img_height * 16;
Vline_baseptr = Uline_baseptr + img_width * img_height * 4;
break;
case V4L2_PIX_FMT_YVU420:
mainbuffer = NULL;
Yline_baseptr = fb;
Vline_baseptr = fb + img_width * img_height * 16;
Uline_baseptr = Vline_baseptr + img_width * img_height * 4;
break;
}
Yline_baseofs = img_width - 4;
UVline_baseofs = (img_width >> 2) - 3;
/* Process 4 lines at a time ( one block height ) */
for ( row=0 ; row<img_height ; row++ ) {
/* Line start reset DC */
dc_y = dc_u = dc_v = 0;
/* Process 16 columns at a time ( 4 block width ) */
for ( col=0 ; col<img_width ; col+=16 ) {
/* Decode blocks
* Block order : Y Y Y Y V U ( Why V before U ?
* that just depends what you call U&V ... I took the
* 'by-the-book' names and that makes V and then U,
* ... just ask the DivIO folks ;) )
*/
if ( decodeBlock(&br, block_y, &dc_y) && (!col) )
/* return; * Bad block, so bad frame ... */
;
decodeBlock(&br, block_y + 16, &dc_y);
decodeBlock(&br, block_y + 32, &dc_y);
decodeBlock(&br, block_y + 48, &dc_y);
decodeBlock(&br, block_v, &dc_v);
decodeBlock(&br, block_u, &dc_u);
/* Copy data to temporary buffers ( to make a complete line ) */
block_idx = 0;
Yline = Yline_baseptr + col;
Uline = Uline_baseptr + (col >> 2);
Vline = Vline_baseptr + (col >> 2);
for ( y=0 ; y<4 ; y++) {
/* Scan line */
for ( x=0 ; x<4 ; x++ ) {
/* Y block */
Yline[ 0] = clamp_adjust(block_y[block_idx ]);
Yline[ 4] = clamp_adjust(block_y[block_idx+16]);
Yline[ 8] = clamp_adjust(block_y[block_idx+32]);
Yline[12] = clamp_adjust(block_y[block_idx+48]);
/* U block */
*Uline = clamp_adjust(block_u[block_idx]);
/* V block */
*Vline = clamp_adjust(block_v[block_idx]);
/* Ajust pointers & index */
block_idx++;
Yline++;
Uline++;
Vline++;
}
/* Adjust pointers */
Yline += Yline_baseofs;
Uline += UVline_baseofs;
Vline += UVline_baseofs;
}
}
/* Handle interpolation special case ( at the end of the lines ) */
Uline = Uline_baseptr + (UVline_baseofs+2);
Vline = Vline_baseptr + (UVline_baseofs+2);
for ( y=0 ; y<4 ; y++ ) {
/* Copy the last pixel */
Uline[1] = Uline[0];
Vline[1] = Vline[0];
/* Adjust ptr */
Uline += UVline_baseofs+4;
Vline += UVline_baseofs+4;
}
/* We have 4 complete lines, so tempbuffer<YUV> -> framebuffer<RGB>
* Go line by line */
switch (dest_pix_fmt) {
case V4L2_PIX_FMT_RGB24:
Yline = Yline_baseptr;
Uline = Uline_baseptr;
Vline = Vline_baseptr;
for ( y=0 ; y<4 ; y++ ) {
/* Process 4 pixel at a time to handle interpolation
* for U & V values */
for ( x=0 ; x<img_width ; x+=4 ) {
/* First pixel */
yc = yuvTbl_y[*(Yline++)];
uc = Uline[0];
vc = Vline[0];
*(fb++) = clamp(( yc + yuvTbl_u1[uc] ) >> 16);
*(fb++) = clamp(( yc - yuvTbl_u2[uc] - yuvTbl_v1[vc] ) >> 16);
*(fb++) = clamp(( yc + yuvTbl_v2[vc] ) >> 16);
/* Second pixel */
yc = yuvTbl_y[*(Yline++)];
uc = ( 3*Uline[0] + Uline[1] ) >> 2;
vc = ( 3*Vline[0] + Vline[1] ) >> 2;
*(fb++) = clamp(( yc + yuvTbl_u1[uc] ) >> 16);
*(fb++) = clamp(( yc - yuvTbl_u2[uc] - yuvTbl_v1[vc] ) >> 16);
*(fb++) = clamp(( yc + yuvTbl_v2[vc] ) >> 16);
/* Third pixel */
yc = yuvTbl_y[*(Yline++)];
uc = ( Uline[0] + Uline[1] ) >> 1;
vc = ( Vline[0] + Vline[1] ) >> 1;
*(fb++) = clamp(( yc + yuvTbl_u1[uc] ) >> 16);
*(fb++) = clamp(( yc - yuvTbl_u2[uc] - yuvTbl_v1[vc] ) >> 16);
*(fb++) = clamp(( yc + yuvTbl_v2[vc] ) >> 16);
/* Fourth pixel */
yc = yuvTbl_y[*(Yline++)];
uc = ( Uline[0] + 3*Uline[1] ) >> 2;
vc = ( Vline[0] + 3*Vline[1] ) >> 2;
*(fb++) = clamp(( yc + yuvTbl_u1[uc] ) >> 16);
*(fb++) = clamp(( yc - yuvTbl_u2[uc] - yuvTbl_v1[vc] ) >> 16);
*(fb++) = clamp(( yc + yuvTbl_v2[vc] ) >> 16);
/* Adjust pointers */
Uline++;
Vline++;
}
/* Adjust pointers */
Uline++;
Vline++;
}
break;
case V4L2_PIX_FMT_BGR24:
Yline = Yline_baseptr;
Uline = Uline_baseptr;
Vline = Vline_baseptr;
for ( y=0 ; y<4 ; y++ ) {
/* Process 4 pixel at a time to handle interpolation
* for U & V values */
for ( x=0 ; x<img_width ; x+=4 ) {
/* First pixel */
yc = yuvTbl_y[*(Yline++)];
uc = Uline[0];
vc = Vline[0];
*(fb++) = clamp(( yc + yuvTbl_v2[vc] ) >> 16);
*(fb++) = clamp(( yc - yuvTbl_u2[uc] - yuvTbl_v1[vc] ) >> 16);
*(fb++) = clamp(( yc + yuvTbl_u1[uc] ) >> 16);
/* Second pixel */
yc = yuvTbl_y[*(Yline++)];
uc = ( 3*Uline[0] + Uline[1] ) >> 2;
vc = ( 3*Vline[0] + Vline[1] ) >> 2;
*(fb++) = clamp(( yc + yuvTbl_v2[vc] ) >> 16);
*(fb++) = clamp(( yc - yuvTbl_u2[uc] - yuvTbl_v1[vc] ) >> 16);
*(fb++) = clamp(( yc + yuvTbl_u1[uc] ) >> 16);
/* Third pixel */
yc = yuvTbl_y[*(Yline++)];
uc = ( Uline[0] + Uline[1] ) >> 1;
vc = ( Vline[0] + Vline[1] ) >> 1;
*(fb++) = clamp(( yc + yuvTbl_v2[vc] ) >> 16);
*(fb++) = clamp(( yc - yuvTbl_u2[uc] - yuvTbl_v1[vc] ) >> 16);
*(fb++) = clamp(( yc + yuvTbl_u1[uc] ) >> 16);
/* Fourth pixel */
yc = yuvTbl_y[*(Yline++)];
uc = ( Uline[0] + 3*Uline[1] ) >> 2;
vc = ( Vline[0] + 3*Vline[1] ) >> 2;
*(fb++) = clamp(( yc + yuvTbl_v2[vc] ) >> 16);
*(fb++) = clamp(( yc - yuvTbl_u2[uc] - yuvTbl_v1[vc] ) >> 16);
*(fb++) = clamp(( yc + yuvTbl_u1[uc] ) >> 16);
/* Adjust pointers */
Uline++;
Vline++;
}
/* Adjust pointers */
Uline++;
Vline++;
}
break;
case V4L2_PIX_FMT_YUV420:
case V4L2_PIX_FMT_YVU420:
Yline_baseptr += img_width * 4;
Uline_baseptr += img_width;
Vline_baseptr += img_width;
break;
}
}
/* Free our buffer */
if (mainbuffer != NULL)
free(mainbuffer);
return 0;
}
/*
Return-Path: tnt@246tNt.com
Received: from zimbra16-e3.priv.proxad.net (LHLO
zimbra16-e3.priv.proxad.net) (172.20.243.166) by
zimbra16-e3.priv.proxad.net with LMTP; Mon, 14 Feb 2011 21:10:38 +0100
(CET)
Received: from mailrelay011.isp.belgacom.be (mx26-g26.priv.proxad.net [172.20.243.96])
by zimbra16-e3.priv.proxad.net (Postfix) with ESMTP id 1A661157C5B
for <moinejf@free.fr>; Mon, 14 Feb 2011 21:10:38 +0100 (CET)
Received: from mailrelay011.isp.belgacom.be ([195.238.6.178])
by mx1-g20.free.fr (MXproxy) for moinejf@free.fr ;
Mon, 14 Feb 2011 21:10:36 +0100 (CET)
X-ProXaD-SC: state=HAM score=0
X-Belgacom-Dynamic: yes
X-IronPort-Anti-Spam-Filtered: true
X-IronPort-Anti-Spam-Result: ApIBAKsaWU1XQ5W2/2dsb2JhbAAMhBHOEpA5gSeBaYFYdgSLfw
Received: from 182.149-67-87.adsl-dyn.isp.belgacom.be (HELO [10.0.0.129]) ([87.67.149.182])
by relay.skynet.be with ESMTP; 14 Feb 2011 21:10:36 +0100
Message-ID: <4D598C7C.7080307@246tNt.com>
Date: Mon, 14 Feb 2011 21:11:40 +0100
From: Sylvain Munaut <tnt@246tNt.com>
User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.13) Gecko/20101219 Lightning/1.0b3pre Thunderbird/3.1.7
MIME-Version: 1.0
To: Jean-Francois Moine <moinejf@free.fr>
CC: Kjell Claesson <keyson@users.sourceforge.net>
Subject: Re: nw80x as a gspca subdriv
References: <20110209204208.4b19df88@tele> <4D53B3BF.9050908@246tNt.com> <20110214205107.18c29303@tele>
In-Reply-To: <20110214205107.18c29303@tele>
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 7bit
[snip]
> May I have your permission to relicense your JPEG Lite decompression
> code under the LGPL (version 2 or later)?
Yes, sure.
"""
I hereby allow the nw80x driver code, including the jpeg lite decoding
routines, to be used and distributed under the LGPL v2 or later.
"""
[snip]
Cheers,
Sylvain
*/