Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

h261: K&R formatting and prettyprinting cosmetics

Browse Source
pull/21/head
Diego Biurrun 12 years ago
parent 66ac3dbf1e
commit b78f81c803
6 changed files with 476 additions and 454 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 55
      libavcodec/h261.c
  2. 6
      libavcodec/h261.h
  3. 45
      libavcodec/h261_parser.c
  4. 145
      libavcodec/h261data.h
  5. 463
      libavcodec/h261dec.c
  6. 216
      libavcodec/h261enc.c

55
libavcodec/h261.c
Unescape View File

@ -28,51 +28,52 @@
#include "avcodec.h"
#include "h261.h"
#define IS_FIL(a) ((a)&MB_TYPE_H261_FIL)
#define IS_FIL(a) ((a) & MB_TYPE_H261_FIL)
uint8_t ff_h261_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
uint8_t ff_h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];
static void h261_loop_filter(uint8_t *src, int stride)
{
int x,y,xy,yz;
int x, y, xy, yz;
int temp[64];
for(x=0; x<8; x++){
temp[x ] = 4*src[x ];
temp[x + 7*8] = 4*src[x + 7*stride];
for (x = 0; x < 8; x++) {
temp[x] = 4 * src[x];
temp[x + 7 * 8] = 4 * src[x + 7 * stride];
}
for(y=1; y<7; y++){
for(x=0; x<8; x++){
xy = y * stride + x;
yz = y * 8 + x;
temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
for (y = 1; y < 7; y++) {
for (x = 0; x < 8; x++) {
xy = y * stride + x;
yz = y * 8 + x;
temp[yz] = src[xy - stride] + 2 * src[xy] + src[xy + stride];
}
}
for(y=0; y<8; y++){
src[ y*stride] = (temp[ y*8] + 2)>>2;
src[7+y*stride] = (temp[7+y*8] + 2)>>2;
for(x=1; x<7; x++){
xy = y * stride + x;
yz = y * 8 + x;
src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
for (y = 0; y < 8; y++) {
src[y * stride] = (temp[y * 8] + 2) >> 2;
src[y * stride + 7] = (temp[y * 8 + 7] + 2) >> 2;
for (x = 1; x < 7; x++) {
xy = y * stride + x;
yz = y * 8 + x;
src[xy] = (temp[yz - 1] + 2 * temp[yz] + temp[yz + 1] + 8) >> 4;
}
}
}
void ff_h261_loop_filter(MpegEncContext *s){
H261Context * h= (H261Context*)s;
const int linesize = s->linesize;
const int uvlinesize= s->uvlinesize;
uint8_t *dest_y = s->dest[0];
uint8_t *dest_cb= s->dest[1];
uint8_t *dest_cr= s->dest[2];
void ff_h261_loop_filter(MpegEncContext *s)
{
H261Context *h = (H261Context *)s;
const int linesize = s->linesize;
const int uvlinesize = s->uvlinesize;
uint8_t *dest_y = s->dest[0];
uint8_t *dest_cb = s->dest[1];
uint8_t *dest_cr = s->dest[2];
if(!(IS_FIL (h->mtype)))
if (!(IS_FIL(h->mtype)))
return;
h261_loop_filter(dest_y, linesize);
h261_loop_filter(dest_y + 8, linesize);
h261_loop_filter(dest_y + 8, linesize);
h261_loop_filter(dest_y + 8 * linesize, linesize);
h261_loop_filter(dest_y + 8 * linesize + 8, linesize);
h261_loop_filter(dest_cb, uvlinesize);

6
libavcodec/h261.h
Unescape View File

@ -33,7 +33,7 @@
/**
* H261Context
*/
typedef struct H261Context{
typedef struct H261Context {
MpegEncContext s;
int current_mba;
@ -44,11 +44,11 @@ typedef struct H261Context{
int current_mv_y;
int gob_number;
int gob_start_code_skipped; // 1 if gob start code is already read before gob header is read
}H261Context;
} H261Context;
#define MB_TYPE_H261_FIL 0x800000
extern uint8_t ff_h261_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
extern uint8_t ff_h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];
void ff_h261_loop_filter(MpegEncContext *s);

45
libavcodec/h261_parser.c
Unescape View File

@ -27,38 +27,39 @@
#include "parser.h"
static int h261_find_frame_end(ParseContext *pc, AVCodecContext* avctx, const uint8_t *buf, int buf_size){
static int h261_find_frame_end(ParseContext *pc, AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
int vop_found, i, j;
uint32_t state;
vop_found= pc->frame_start_found;
state= pc->state;
vop_found = pc->frame_start_found;
state = pc->state;
for(i=0; i<buf_size && !vop_found; i++){
state= (state<<8) | buf[i];
for(j=0; j<8; j++){
if(((state>>j)&0xFFFFF0) == 0x000100){
vop_found=1;
for (i = 0; i < buf_size && !vop_found; i++) {
state = (state << 8) | buf[i];
for (j = 0; j < 8; j++) {
if (((state >> j) & 0xFFFFF0) == 0x000100) {
vop_found = 1;
break;
}
}
}
if(vop_found){
for(; i<buf_size; i++){
state= (state<<8) | buf[i];
for(j=0; j<8; j++){
if(((state>>j)&0xFFFFF0) == 0x000100){
pc->frame_start_found=0;
pc->state= (state>>(3*8))+0xFF00;
return i-2;
if (vop_found) {
for (; i < buf_size; i++) {
state = (state << 8) | buf[i];
for (j = 0; j < 8; j++) {
if (((state >> j) & 0xFFFFF0) == 0x000100) {
pc->frame_start_found = 0;
pc->state = (state >> (3 * 8)) + 0xFF00;
return i - 2;
}
}
}
}
pc->frame_start_found= vop_found;
pc->state= state;
pc->frame_start_found = vop_found;
pc->state = state;
return END_NOT_FOUND;
}
@ -70,13 +71,13 @@ static int h261_parse(AVCodecParserContext *s,
ParseContext *pc = s->priv_data;
int next;
next= h261_find_frame_end(pc,avctx, buf, buf_size);
next = h261_find_frame_end(pc, avctx, buf, buf_size);
if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
*poutbuf = NULL;
*poutbuf = NULL;
*poutbuf_size = 0;
return buf_size;
}
*poutbuf = buf;
*poutbuf = buf;
*poutbuf_size = buf_size;
return next;
}

145
libavcodec/h261data.h
Unescape View File

@ -28,6 +28,7 @@
#define AVCODEC_H261DATA_H
#include <stdint.h>
#include "h261.h"
// H.261 VLC table for macroblock addressing
@ -41,8 +42,8 @@ static const uint8_t h261_mba_code[35] = {
32, 31, 30, 29,
28, 27, 26, 25,
24,
15, //(MBA stuffing)
1 //(start code)
15, // (MBA stuffing)
1 // (start code)
};
static const uint8_t h261_mba_bits[35] = {
@ -55,102 +56,100 @@ static const uint8_t h261_mba_bits[35] = {
11, 11, 11, 11,
11, 11, 11, 11,
11,
11, //(MBA stuffing)
16 //(start code)
11, // (MBA stuffing)
16 // (start code)
};
//H.261 VLC table for macroblock type
// H.261 VLC table for macroblock type
static const uint8_t h261_mtype_code[10] = {
1, 1, 1, 1,
1, 1, 1, 1,
1, 1
1, 1, 1, 1,
1, 1, 1, 1,
1, 1
};
static const uint8_t h261_mtype_bits[10] = {
4, 7, 1, 5,
9, 8, 10, 3,
2, 6
4, 7, 1, 5,
9, 8, 10, 3,
2, 6
};
static const int h261_mtype_map[10]= {
MB_TYPE_INTRA4x4,
MB_TYPE_INTRA4x4 | MB_TYPE_QUANT,
MB_TYPE_CBP,
MB_TYPE_QUANT | MB_TYPE_CBP,
MB_TYPE_16x16,
MB_TYPE_CBP | MB_TYPE_16x16,
MB_TYPE_QUANT | MB_TYPE_CBP | MB_TYPE_16x16,
MB_TYPE_16x16 | MB_TYPE_H261_FIL,
MB_TYPE_CBP | MB_TYPE_16x16 | MB_TYPE_H261_FIL,
MB_TYPE_QUANT | MB_TYPE_CBP | MB_TYPE_16x16 | MB_TYPE_H261_FIL
static const int h261_mtype_map[10] = {
MB_TYPE_INTRA4x4,
MB_TYPE_INTRA4x4 | MB_TYPE_QUANT,
MB_TYPE_CBP,
MB_TYPE_CBP | MB_TYPE_QUANT,
MB_TYPE_16x16,
MB_TYPE_16x16 | MB_TYPE_CBP,
MB_TYPE_16x16 | MB_TYPE_CBP | MB_TYPE_QUANT,
MB_TYPE_16x16 | MB_TYPE_H261_FIL,
MB_TYPE_16x16 | MB_TYPE_H261_FIL | MB_TYPE_CBP,
MB_TYPE_16x16 | MB_TYPE_H261_FIL | MB_TYPE_CBP | MB_TYPE_QUANT
};
//H.261 VLC table for motion vectors
// H.261 VLC table for motion vectors
static const uint8_t h261_mv_tab[17][2] = {
{1,1}, {1,2}, {1,3}, {1,4}, {3,6}, {5,7}, {4,7}, {3,7},
{11,9}, {10,9}, {9,9}, {17,10}, {16,10}, {15,10}, {14,10}, {13,10}, {12,10}
{ 1, 1 }, { 1, 2 }, { 1, 3 }, { 1, 4 }, { 3, 6 }, { 5, 7 }, { 4, 7 }, { 3, 7 },
{ 11, 9 }, { 10, 9 }, { 9, 9 }, { 17, 10 }, { 16, 10 }, { 15, 10 }, { 14, 10 }, { 13, 10 }, { 12, 10 }
};
static const int mvmap[17] =
{
static const int mvmap[17] = {
0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16
};
//H.261 VLC table for coded block pattern
static const uint8_t h261_cbp_tab[63][2] =
{
{11,5}, {9,5}, {13,6}, {13,4}, {23,7}, {19,7}, {31,8}, {12,4},
{22,7}, {18,7}, {30,8}, {19,5}, {27,8}, {23,8}, {19,8}, {11,4},
{21,7}, {17,7}, {29,8}, {17,5}, {25,8}, {21,8}, {17,8}, {15,6},
{15,8}, {13,8}, {3,9}, {15,5}, {11,8}, {7,8}, {7,9}, {10,4},
{20,7}, {16,7}, {28,8}, {14,6}, {14,8}, {12,8}, {2,9}, {16,5},
{24,8}, {20,8}, {16,8}, {14,5}, {10,8}, {6,8}, {6,9}, {18,5},
{26,8}, {22,8}, {18,8}, {13,5}, {9,8}, {5,8}, {5,9}, {12,5},
{8,8}, {4,8}, {4,9}, {7,3}, {10,5}, {8,5}, {12,6}
// H.261 VLC table for coded block pattern
static const uint8_t h261_cbp_tab[63][2] = {
{ 11, 5 }, { 9, 5 }, { 13, 6 }, { 13, 4 }, { 23, 7 }, { 19, 7 }, { 31, 8 }, { 12, 4 },
{ 22, 7 }, { 18, 7 }, { 30, 8 }, { 19, 5 }, { 27, 8 }, { 23, 8 }, { 19, 8 }, { 11, 4 },
{ 21, 7 }, { 17, 7 }, { 29, 8 }, { 17, 5 }, { 25, 8 }, { 21, 8 }, { 17, 8 }, { 15, 6 },
{ 15, 8 }, { 13, 8 }, { 3, 9 }, { 15, 5 }, { 11, 8 }, { 7, 8 }, { 7, 9 }, { 10, 4 },
{ 20, 7 }, { 16, 7 }, { 28, 8 }, { 14, 6 }, { 14, 8 }, { 12, 8 }, { 2, 9 }, { 16, 5 },
{ 24, 8 }, { 20, 8 }, { 16, 8 }, { 14, 5 }, { 10, 8 }, { 6, 8 }, { 6, 9 }, { 18, 5 },
{ 26, 8 }, { 22, 8 }, { 18, 8 }, { 13, 5 }, { 9, 8 }, { 5, 8 }, { 5, 9 }, { 12, 5 },
{ 8, 8 }, { 4, 8 }, { 4, 9 }, { 7, 3 }, { 10, 5 }, { 8, 5 }, { 12, 6 }
};
//H.261 VLC table for transform coefficients
// H.261 VLC table for transform coefficients
static const uint16_t h261_tcoeff_vlc[65][2] = {
{ 0x2, 2 }, { 0x3, 2 },{ 0x4, 4 },{ 0x5, 5 },
{ 0x6, 7 },{ 0x26, 8 },{ 0x21, 8 },{ 0xa, 10 },
{ 0x1d, 12 },{ 0x18, 12 },{ 0x13, 12 },{ 0x10 , 12 },
{ 0x1a, 13},{ 0x19, 13 }, { 0x18, 13 }, { 0x17, 13 },
{ 0x3, 3 }, { 0x6, 6 }, { 0x25 , 8 }, { 0xc, 10 },
{ 0x1b, 12 }, { 0x16, 13 }, { 0x15, 13 }, { 0x5, 4},
{ 0x4, 7}, { 0xb, 10 }, { 0x14, 12 }, { 0x14, 13 },
{ 0x7, 5 }, { 0x24, 8 }, { 0x1c, 12 }, { 0x13, 13 },
{ 0x6, 5 }, { 0xf, 10 }, { 0x12, 12}, { 0x7, 6},
{ 0x9 , 10 }, { 0x12, 13 }, { 0x5, 6 }, { 0x1e, 12 },
{ 0x4, 6 }, { 0x15, 12 }, { 0x7, 7 }, { 0x11, 12},
{ 0x5, 7 }, { 0x11, 13 }, { 0x27, 8 }, { 0x10, 13 },
{ 0x23, 8 }, { 0x22, 8 }, { 0x20, 8 }, { 0xe , 10 },
{ 0xd, 10 }, { 0x8, 10 },{ 0x1f, 12 }, { 0x1a, 12 },
{ 0x19, 12 }, { 0x17, 12 }, { 0x16, 12}, { 0x1f, 13},
{ 0x1e, 13 }, { 0x1d, 13 }, { 0x1c, 13}, { 0x1b, 13},
{ 0x1, 6 } //escape
{ 0x2, 2 }, { 0x3, 2 }, { 0x4, 4 }, { 0x5, 5 },
{ 0x6, 7 }, { 0x26, 8 }, { 0x21, 8 }, { 0xa, 10 },
{ 0x1d, 12 }, { 0x18, 12 }, { 0x13, 12 }, { 0x10, 12 },
{ 0x1a, 13 }, { 0x19, 13 }, { 0x18, 13 }, { 0x17, 13 },
{ 0x3, 3 }, { 0x6, 6 }, { 0x25, 8 }, { 0xc, 10 },
{ 0x1b, 12 }, { 0x16, 13 }, { 0x15, 13 }, { 0x5, 4 },
{ 0x4, 7 }, { 0xb, 10 }, { 0x14, 12 }, { 0x14, 13 },
{ 0x7, 5 }, { 0x24, 8 }, { 0x1c, 12 }, { 0x13, 13 },
{ 0x6, 5 }, { 0xf, 10 }, { 0x12, 12 }, { 0x7, 6 },
{ 0x9, 10 }, { 0x12, 13 }, { 0x5, 6 }, { 0x1e, 12 },
{ 0x4, 6 }, { 0x15, 12 }, { 0x7, 7 }, { 0x11, 12 },
{ 0x5, 7 }, { 0x11, 13 }, { 0x27, 8 }, { 0x10, 13 },
{ 0x23, 8 }, { 0x22, 8 }, { 0x20, 8 }, { 0xe, 10 },
{ 0xd, 10 }, { 0x8, 10 }, { 0x1f, 12 }, { 0x1a, 12 },
{ 0x19, 12 }, { 0x17, 12 }, { 0x16, 12 }, { 0x1f, 13 },
{ 0x1e, 13 }, { 0x1d, 13 }, { 0x1c, 13 }, { 0x1b, 13 },
{ 0x1, 6 } // escape
};
static const int8_t h261_tcoeff_level[64] = {
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
1, 2, 3, 4, 5, 6, 7, 1,
2, 3, 4, 5, 1, 2, 3, 4,
1, 2, 3, 1, 2, 3, 1, 2,
1, 2, 1, 2, 1, 2, 1, 2,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15,
1, 2, 3, 4, 5, 6, 7, 1,
2, 3, 4, 5, 1, 2, 3, 4,
1, 2, 3, 1, 2, 3, 1, 2,
1, 2, 1, 2, 1, 2, 1, 2,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1
};
static const int8_t h261_tcoeff_run[64] = {
0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1, 2, 2,
2, 2, 2, 3, 3, 3, 3, 4,
4, 4, 5, 5, 5, 6, 6, 7,
7, 8, 8, 9, 9, 10, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26
0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1,
1, 1, 1, 1, 1, 1, 2, 2,
2, 2, 2, 3, 3, 3, 3, 4,
4, 4, 5, 5, 5, 6, 6, 7,
7, 8, 8, 9, 9, 10, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26
};
static RLTable h261_rl_tcoeff = {

463
libavcodec/h261dec.c
Unescape View File

@ -44,47 +44,46 @@ static VLC h261_mtype_vlc;
static VLC h261_mv_vlc;
static VLC h261_cbp_vlc;
static int h261_decode_block(H261Context * h, int16_t * block, int n, int coded);
static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded);
static av_cold void h261_decode_init_vlc(H261Context *h){
static av_cold void h261_decode_init_vlc(H261Context *h)
{
static int done = 0;
if(!done){
if (!done) {
done = 1;
INIT_VLC_STATIC(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
h261_mba_bits, 1, 1,
h261_mba_code, 1, 1, 662);
h261_mba_bits, 1, 1,
h261_mba_code, 1, 1, 662);
INIT_VLC_STATIC(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
h261_mtype_bits, 1, 1,
h261_mtype_code, 1, 1, 80);
h261_mtype_bits, 1, 1,
h261_mtype_code, 1, 1, 80);
INIT_VLC_STATIC(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
&h261_mv_tab[0][1], 2, 1,
&h261_mv_tab[0][0], 2, 1, 144);
&h261_mv_tab[0][1], 2, 1,
&h261_mv_tab[0][0], 2, 1, 144);
INIT_VLC_STATIC(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
&h261_cbp_tab[0][1], 2, 1,
&h261_cbp_tab[0][0], 2, 1, 512);
&h261_cbp_tab[0][1], 2, 1,
&h261_cbp_tab[0][0], 2, 1, 512);
ff_init_rl(&h261_rl_tcoeff, ff_h261_rl_table_store);
INIT_VLC_RL(h261_rl_tcoeff, 552);
}
}
static av_cold int h261_decode_init(AVCodecContext *avctx){
H261Context *h= avctx->priv_data;
MpegEncContext * const s = &h->s;
static av_cold int h261_decode_init(AVCodecContext *avctx)
{
H261Context *h = avctx->priv_data;
MpegEncContext *const s = &h->s;
// set defaults
ff_MPV_decode_defaults(s);
s->avctx = avctx;
s->width = s->avctx->coded_width;
s->height = s->avctx->coded_height;
s->codec_id = s->avctx->codec->id;
s->out_format = FMT_H261;
s->low_delay= 1;
avctx->pix_fmt= AV_PIX_FMT_YUV420P;
s->codec_id= avctx->codec->id;
s->avctx = avctx;
s->width = s->avctx->coded_width;
s->height = s->avctx->coded_height;
s->codec_id = s->avctx->codec->id;
s->out_format = FMT_H261;
s->low_delay = 1;
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
s->codec_id = avctx->codec->id;
h261_decode_init_vlc(h);
@ -97,14 +96,15 @@ static av_cold int h261_decode_init(AVCodecContext *avctx){
* Decode the group of blocks header or slice header.
* @return <0 if an error occurred
*/
static int h261_decode_gob_header(H261Context *h){
static int h261_decode_gob_header(H261Context *h)
{
unsigned int val;
MpegEncContext * const s = &h->s;
MpegEncContext *const s = &h->s;
if ( !h->gob_start_code_skipped ){
if (!h->gob_start_code_skipped) {
/* Check for GOB Start Code */
val = show_bits(&s->gb, 15);
if(val)
if (val)
return -1;
/* We have a GBSC */
@ -114,34 +114,34 @@ static int h261_decode_gob_header(H261Context *h){
h->gob_start_code_skipped = 0;
h->gob_number = get_bits(&s->gb, 4); /* GN */
s->qscale = get_bits(&s->gb, 5); /* GQUANT */
s->qscale = get_bits(&s->gb, 5); /* GQUANT */
/* Check if gob_number is valid */
if (s->mb_height==18){ //cif
if ((h->gob_number<=0) || (h->gob_number>12))
if (s->mb_height == 18) { // CIF
if ((h->gob_number <= 0) || (h->gob_number > 12))
return -1;
}
else{ //qcif
if ((h->gob_number!=1) && (h->gob_number!=3) && (h->gob_number!=5))
} else { // QCIF
if ((h->gob_number != 1) && (h->gob_number != 3) &&
(h->gob_number != 5))
return -1;
}
/* GEI */
while (get_bits1(&s->gb) != 0) {
while (get_bits1(&s->gb) != 0)
skip_bits(&s->gb, 8);
}
if(s->qscale==0) {
if (s->qscale == 0) {
av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
if (s->avctx->err_recognition & AV_EF_BITSTREAM)
return -1;
}
// For the first transmitted macroblock in a GOB, MBA is the absolute address. For
// subsequent macroblocks, MBA is the difference between the absolute addresses of
// the macroblock and the last transmitted macroblock.
/* For the first transmitted macroblock in a GOB, MBA is the absolute
* address. For subsequent macroblocks, MBA is the difference between
* the absolute addresses of the macroblock and the last transmitted
* macroblock. */
h->current_mba = 0;
h->mba_diff = 0;
h->mba_diff = 0;
return 0;
}
@ -150,35 +150,35 @@ static int h261_decode_gob_header(H261Context *h){
* Decode the group of blocks / video packet header.
* @return <0 if no resync found
*/
static int ff_h261_resync(H261Context *h){
MpegEncContext * const s = &h->s;
static int ff_h261_resync(H261Context *h)
{
MpegEncContext *const s = &h->s;
int left, ret;
if ( h->gob_start_code_skipped ){
ret= h261_decode_gob_header(h);
if(ret>=0)
if (h->gob_start_code_skipped) {
ret = h261_decode_gob_header(h);
if (ret >= 0)
return 0;
}
else{
if(show_bits(&s->gb, 15)==0){
ret= h261_decode_gob_header(h);
if(ret>=0)
} else {
if (show_bits(&s->gb, 15) == 0) {
ret = h261_decode_gob_header(h);
if (ret >= 0)
return 0;
}
//OK, it is not where it is supposed to be ...
s->gb= s->last_resync_gb;
// OK, it is not where it is supposed to be ...
s->gb = s->last_resync_gb;
align_get_bits(&s->gb);
left= get_bits_left(&s->gb);
left = get_bits_left(&s->gb);
for(;left>15+1+4+5; left-=8){
if(show_bits(&s->gb, 15)==0){
GetBitContext bak= s->gb;
for (; left > 15 + 1 + 4 + 5; left -= 8) {
if (show_bits(&s->gb, 15) == 0) {
GetBitContext bak = s->gb;
ret= h261_decode_gob_header(h);
if(ret>=0)
ret = h261_decode_gob_header(h);
if (ret >= 0)
return 0;
s->gb= bak;
s->gb = bak;
}
skip_bits(&s->gb, 8);
}
@ -191,32 +191,32 @@ static int ff_h261_resync(H261Context *h){
* Decode skipped macroblocks.
* @return 0
*/
static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2)
{
MpegEncContext * const s = &h->s;
MpegEncContext *const s = &h->s;
int i;
s->mb_intra = 0;
for(i=mba1; i<mba2; i++){
for (i = mba1; i < mba2; i++) {
int j, xy;
s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11;
s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11;
xy = s->mb_x + s->mb_y * s->mb_stride;
s->mb_x = ((h->gob_number - 1) % 2) * 11 + i % 11;
s->mb_y = ((h->gob_number - 1) / 2) * 3 + i / 11;
xy = s->mb_x + s->mb_y * s->mb_stride;
ff_init_block_index(s);
ff_update_block_index(s);
for(j=0;j<6;j++)
for (j = 0; j < 6; j++)
s->block_last_index[j] = -1;
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
s->mv[0][0][0] = 0;
s->mv[0][0][1] = 0;
s->mb_skipped = 1;
h->mtype &= ~MB_TYPE_H261_FIL;
s->mv[0][0][0] = 0;
s->mv[0][0][1] = 0;
s->mb_skipped = 1;
h->mtype &= ~MB_TYPE_H261_FIL;
ff_MPV_decode_mb(s, s->block);
}
@ -224,44 +224,48 @@ static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
return 0;
}
static int decode_mv_component(GetBitContext *gb, int v){
static int decode_mv_component(GetBitContext *gb, int v)
{
int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2);
/* check if mv_diff is valid */
if ( mv_diff < 0 )
if (mv_diff < 0)
return v;
mv_diff = mvmap[mv_diff];
if(mv_diff && !get_bits1(gb))
mv_diff= -mv_diff;
if (mv_diff && !get_bits1(gb))
mv_diff = -mv_diff;
v += mv_diff;
if (v <=-16) v+= 32;
else if(v >= 16) v-= 32;
if (v <= -16)
v += 32;
else if (v >= 16)
v -= 32;
return v;
}
static int h261_decode_mb(H261Context *h){
MpegEncContext * const s = &h->s;
static int h261_decode_mb(H261Context *h)
{
MpegEncContext *const s = &h->s;
int i, cbp, xy;
cbp = 63;
// Read mba
do{
h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
do {
h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table,
H261_MBA_VLC_BITS, 2);
/* Check for slice end */
/* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
if (h->mba_diff == MBA_STARTCODE){ // start code
if (h->mba_diff == MBA_STARTCODE) { // start code
h->gob_start_code_skipped = 1;
return SLICE_END;
}
}
while( h->mba_diff == MBA_STUFFING ); // stuffing
} while (h->mba_diff == MBA_STUFFING); // stuffing
if ( h->mba_diff < 0 ){
if (h->mba_diff < 0) {
if (get_bits_left(&s->gb) <= 7)
return SLICE_END;
@ -269,15 +273,15 @@ static int h261_decode_mb(H261Context *h){
return SLICE_ERROR;
}
h->mba_diff += 1;
h->mba_diff += 1;
h->current_mba += h->mba_diff;
if ( h->current_mba > MBA_STUFFING )
if (h->current_mba > MBA_STUFFING)
return SLICE_ERROR;
s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
xy = s->mb_x + s->mb_y * s->mb_stride;
s->mb_x = ((h->gob_number - 1) % 2) * 11 + ((h->current_mba - 1) % 11);
s->mb_y = ((h->gob_number - 1) / 2) * 3 + ((h->current_mba - 1) / 11);
xy = s->mb_x + s->mb_y * s->mb_stride;
ff_init_block_index(s);
ff_update_block_index(s);
@ -286,64 +290,62 @@ static int h261_decode_mb(H261Context *h){
h->mtype = h261_mtype_map[h->mtype];
// Read mquant
if ( IS_QUANT ( h->mtype ) ){
if (IS_QUANT(h->mtype))
ff_set_qscale(s, get_bits(&s->gb, 5));
}
s->mb_intra = IS_INTRA4x4(h->mtype);
// Read mv
if ( IS_16X16 ( h->mtype ) ){
// Motion vector data is included for all MC macroblocks. MVD is obtained from the macroblock vector by subtracting the
// vector of the preceding macroblock. For this calculation the vector of the preceding macroblock is regarded as zero in the
// following three situations:
// 1) evaluating MVD for macroblocks 1, 12 and 23;
// 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
// 3) MTYPE of the previous macroblock was not MC.
if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
( h->mba_diff != 1))
{
if (IS_16X16(h->mtype)) {
/* Motion vector data is included for all MC macroblocks. MVD is
* obtained from the macroblock vector by subtracting the vector
* of the preceding macroblock. For this calculation the vector
* of the preceding macroblock is regarded as zero in the
* following three situations:
* 1) evaluating MVD for macroblocks 1, 12 and 23;
* 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
* 3) MTYPE of the previous macroblock was not MC. */
if ((h->current_mba == 1) || (h->current_mba == 12) ||
(h->current_mba == 23) || (h->mba_diff != 1)) {
h->current_mv_x = 0;
h->current_mv_y = 0;
}
h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x);
h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y);
}else{
h->current_mv_x = decode_mv_component(&s->gb, h->current_mv_x);
h->current_mv_y = decode_mv_component(&s->gb, h->current_mv_y);
} else {
h->current_mv_x = 0;
h->current_mv_y = 0;
}
// Read cbp
if ( HAS_CBP( h->mtype ) ){
if (HAS_CBP(h->mtype))
cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1;
}
if(s->mb_intra){
if (s->mb_intra) {
s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
goto intra;
}
//set motion vectors
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
s->mv_dir = MV_DIR_FORWARD;
s->mv_type = MV_TYPE_16X16;
s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation
s->mv[0][0][1] = h->current_mv_y * 2;
s->mv[0][0][0] = h->current_mv_x * 2; // gets divided by 2 in motion compensation
s->mv[0][0][1] = h->current_mv_y * 2;
intra:
/* decode each block */
if(s->mb_intra || HAS_CBP(h->mtype)){
if (s->mb_intra || HAS_CBP(h->mtype)) {
s->dsp.clear_blocks(s->block[0]);
for (i = 0; i < 6; i++) {
if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
if (h261_decode_block(h, s->block[i], i, cbp & 32) < 0)
return SLICE_ERROR;
}
cbp+=cbp;
cbp += cbp;
}
}else{
} else {
for (i = 0; i < 6; i++)
s->block_last_index[i]= -1;
s->block_last_index[i] = -1;
}
ff_MPV_decode_mb(s, s->block);
@ -355,81 +357,87 @@ intra:
* Decode a macroblock.
* @return <0 if an error occurred
*/
static int h261_decode_block(H261Context * h, int16_t * block,
int n, int coded)
static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded)
{
MpegEncContext * const s = &h->s;
MpegEncContext *const s = &h->s;
int code, level, i, j, run;
RLTable *rl = &h261_rl_tcoeff;
const uint8_t *scan_table;
// For the variable length encoding there are two code tables, one being used for
// the first transmitted LEVEL in INTER, INTER+MC and INTER+MC+FIL blocks, the second
// for all other LEVELs except the first one in INTRA blocks which is fixed length
// coded with 8 bits.
// NOTE: the two code tables only differ in one VLC so we handle that manually.
/* For the variable length encoding there are two code tables, one being
* used for the first transmitted LEVEL in INTER, INTER + MC and
* INTER + MC + FIL blocks, the second for all other LEVELs except the
* first one in INTRA blocks which is fixed length coded with 8 bits.
* NOTE: The two code tables only differ in one VLC so we handle that
* manually. */
scan_table = s->intra_scantable.permutated;
if (s->mb_intra){
if (s->mb_intra) {
/* DC coef */
level = get_bits(&s->gb, 8);
// 0 (00000000b) and -128 (10000000b) are FORBIDDEN
if((level&0x7F) == 0){
av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
if ((level & 0x7F) == 0) {
av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n",
level, s->mb_x, s->mb_y);
return -1;
}
// The code 1000 0000 is not used, the reconstruction level of 1024 being coded as 1111 1111.
/* The code 1000 0000 is not used, the reconstruction level of 1024
* being coded as 1111 1111. */
if (level == 255)
level = 128;
block[0] = level;
i = 1;
}else if(coded){
i = 1;
} else if (coded) {
// Run Level Code
// EOB Not possible for first level when cbp is available (that's why the table is different)
// 0 1 1s
// * * 0*
// EOB Not possible for first level when cbp is available (that's why the table is different)
// 0 1 1s
// * * 0*
int check = show_bits(&s->gb, 2);
i = 0;
if ( check & 0x2 ){
if (check & 0x2) {
skip_bits(&s->gb, 2);
block[0] = ( check & 0x1 ) ? -1 : 1;
i = 1;
block[0] = (check & 0x1) ? -1 : 1;
i = 1;
}
}else{
} else {
i = 0;
}
if(!coded){
if (!coded) {
s->block_last_index[n] = i - 1;
return 0;
}
for(;;){
for (;;) {
code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
if (code < 0){
av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
if (code < 0) {
av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n",
s->mb_x, s->mb_y);
return -1;
}
if (code == rl->n) {
/* escape */
// The remaining combinations of (run, level) are encoded with a 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits level.
run = get_bits(&s->gb, 6);
/* The remaining combinations of (run, level) are encoded with a
* 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits
* level. */
run = get_bits(&s->gb, 6);
level = get_sbits(&s->gb, 8);
}else if(code == 0){
} else if (code == 0) {
break;
}else{
run = rl->table_run[code];
} else {
run = rl->table_run[code];
level = rl->table_level[code];
if (get_bits1(&s->gb))
level = -level;
}
i += run;
if (i >= 64){
av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
if (i >= 64) {
av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n",
s->mb_x, s->mb_y);
return -1;
}
j = scan_table[i];
j = scan_table[i];
block[j] = level;
i++;
}
s->block_last_index[n] = i-1;
s->block_last_index[n] = i - 1;
return 0;
}
@ -437,33 +445,33 @@ static int h261_decode_block(H261Context * h, int16_t * block,
* Decode the H.261 picture header.
* @return <0 if no startcode found
*/
static int h261_decode_picture_header(H261Context *h){
MpegEncContext * const s = &h->s;
static int h261_decode_picture_header(H261Context *h)
{
MpegEncContext *const s = &h->s;
int format, i;
uint32_t startcode= 0;
uint32_t startcode = 0;
for(i= get_bits_left(&s->gb); i>24; i-=1){
for (i = get_bits_left(&s->gb); i > 24; i -= 1) {
startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
if(startcode == 0x10)
if (startcode == 0x10)
break;
}
if (startcode != 0x10){
if (startcode != 0x10) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
/* temporal reference */
i= get_bits(&s->gb, 5); /* picture timestamp */
if(i < (s->picture_number&31))
i = get_bits(&s->gb, 5); /* picture timestamp */
if (i < (s->picture_number & 31))
i += 32;
s->picture_number = (s->picture_number&~31) + i;
s->picture_number = (s->picture_number & ~31) + i;
s->avctx->time_base= (AVRational){1001, 30000};
s->avctx->time_base = (AVRational) { 1001, 30000 };
s->current_picture.f.pts = s->picture_number;
/* PTYPE starts here */
skip_bits1(&s->gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */
@ -471,16 +479,16 @@ static int h261_decode_picture_header(H261Context *h){
format = get_bits1(&s->gb);
//only 2 formats possible
if (format == 0){//QCIF
s->width = 176;
s->height = 144;
s->mb_width = 11;
// only 2 formats possible
if (format == 0) { // QCIF
s->width = 176;
s->height = 144;
s->mb_width = 11;
s->mb_height = 9;
}else{//CIF
s->width = 352;
s->height = 288;
s->mb_width = 22;
} else { // CIF
s->width = 352;
s->height = 288;
s->mb_width = 22;
s->mb_height = 18;
}
@ -490,39 +498,42 @@ static int h261_decode_picture_header(H261Context *h){
skip_bits1(&s->gb); /* Reserved */
/* PEI */
while (get_bits1(&s->gb) != 0){
while (get_bits1(&s->gb) != 0)
skip_bits(&s->gb, 8);
}
// h261 has no I-FRAMES, but if we pass AV_PICTURE_TYPE_I for the first frame, the codec crashes if it does
// not contain all I-blocks (e.g. when a packet is lost)
/* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
* frame, the codec crashes if it does not contain all I-blocks
* (e.g. when a packet is lost). */
s->pict_type = AV_PICTURE_TYPE_P;
h->gob_number = 0;
return 0;
}
static int h261_decode_gob(H261Context *h){
MpegEncContext * const s = &h->s;
static int h261_decode_gob(H261Context *h)
{
MpegEncContext *const s = &h->s;
ff_set_qscale(s, s->qscale);
/* decode mb's */
while(h->current_mba <= MBA_STUFFING)
{
while (h->current_mba <= MBA_STUFFING) {
int ret;
/* DCT & quantize */
ret= h261_decode_mb(h);
if(ret<0){
if(ret==SLICE_END){
ret = h261_decode_mb(h);
if (ret < 0) {
if (ret == SLICE_END) {
h261_decode_mb_skipped(h, h->current_mba, 33);
return 0;
}
av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n",
s->mb_x + s->mb_y * s->mb_stride);
return -1;
}
h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1);
h261_decode_mb_skipped(h,
h->current_mba - h->mba_diff,
h->current_mba - 1);
}
return -1;
@ -531,62 +542,64 @@ static int h261_decode_gob(H261Context *h){
/**
* returns the number of bytes consumed for building the current frame
*/
static int get_consumed_bytes(MpegEncContext *s, int buf_size){
int pos= get_bits_count(&s->gb)>>3;
if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
if(pos+10>buf_size) pos=buf_size; // oops ;)
static int get_consumed_bytes(MpegEncContext *s, int buf_size)
{
int pos = get_bits_count(&s->gb) >> 3;
if (pos == 0)
pos = 1; // avoid infinite loops (i doubt that is needed but ...)
if (pos + 10 > buf_size)
pos = buf_size; // oops ;)
return pos;
}
static int h261_decode_frame(AVCodecContext *avctx,
void *data, int *got_frame,
AVPacket *avpkt)
static int h261_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
H261Context *h= avctx->priv_data;
MpegEncContext *s = &h->s;
int buf_size = avpkt->size;
H261Context *h = avctx->priv_data;
MpegEncContext *s = &h->s;
int ret;
AVFrame *pict = data;
av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
av_dlog(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
s->flags= avctx->flags;
s->flags2= avctx->flags2;
s->flags = avctx->flags;
s->flags2 = avctx->flags2;
h->gob_start_code_skipped=0;
h->gob_start_code_skipped = 0;
retry:
init_get_bits(&s->gb, buf, buf_size * 8);
init_get_bits(&s->gb, buf, buf_size*8);
if(!s->context_initialized){
if (ff_MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
if (!s->context_initialized)
// we need the IDCT permutaton for reading a custom matrix
if (ff_MPV_common_init(s) < 0)
return -1;
}
//we need to set current_picture_ptr before reading the header, otherwise we cannot store anyting im there
/* We need to set current_picture_ptr before reading the header,
* otherwise we cannot store anything in there. */
if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
int i= ff_find_unused_picture(s, 0);
int i = ff_find_unused_picture(s, 0);
if (i < 0)
return i;
s->current_picture_ptr= &s->picture[i];
s->current_picture_ptr = &s->picture[i];
}
ret = h261_decode_picture_header(h);
/* skip if the header was thrashed */
if (ret < 0){
if (ret < 0) {
av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
return -1;
}
if (s->width != avctx->coded_width || s->height != avctx->coded_height){
ParseContext pc= s->parse_context; //FIXME move this demuxing hack to libavformat
s->parse_context.buffer=0;
if (s->width != avctx->coded_width || s->height != avctx->coded_height) {
ParseContext pc = s->parse_context; // FIXME move this demuxing hack to libavformat
s->parse_context.buffer = 0;
ff_MPV_common_end(s);
s->parse_context= pc;
s->parse_context = pc;
}
if (!s->context_initialized) {
avcodec_set_dimensions(avctx, s->width, s->height);
@ -598,29 +611,29 @@ retry:
s->current_picture.f.pict_type = s->pict_type;
s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
|| avctx->skip_frame >= AVDISCARD_ALL)
if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
avctx->skip_frame >= AVDISCARD_ALL)
return get_consumed_bytes(s, buf_size);
if(ff_MPV_frame_start(s, avctx) < 0)
if (ff_MPV_frame_start(s, avctx) < 0)
return -1;
ff_mpeg_er_frame_start(s);
/* decode each macroblock */
s->mb_x=0;
s->mb_y=0;
s->mb_x = 0;
s->mb_y = 0;
while(h->gob_number < (s->mb_height==18 ? 12 : 5)){
if(ff_h261_resync(h)<0)
while (h->gob_number < (s->mb_height == 18 ? 12 : 5)) {
if (ff_h261_resync(h) < 0)
break;
h261_decode_gob(h);
}
ff_MPV_frame_end(s);
assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
assert(s->current_picture.f.pict_type == s->pict_type);
assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
assert(s->current_picture.f.pict_type == s->pict_type);
if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
return ret;
@ -633,7 +646,7 @@ assert(s->current_picture.f.pict_type == s->pict_type);
static av_cold int h261_decode_end(AVCodecContext *avctx)
{
H261Context *h= avctx->priv_data;
H261Context *h = avctx->priv_data;
MpegEncContext *s = &h->s;
ff_MPV_common_end(s);

216
libavcodec/h261enc.c
Unescape View File

@ -31,10 +31,11 @@
#include "h261.h"
#include "h261data.h"
static void h261_encode_block(H261Context * h, int16_t * block,
static void h261_encode_block(H261Context *h, int16_t *block,
int n);
int ff_h261_get_picture_format(int width, int height){
int ff_h261_get_picture_format(int width, int height)
{
// QCIF
if (width == 176 && height == 144)
return 0;
@ -46,8 +47,9 @@ int ff_h261_get_picture_format(int width, int height){
return -1;
}
void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
H261Context * h = (H261Context *) s;
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
{
H261Context *h = (H261Context *)s;
int format, temp_ref;
avpriv_align_put_bits(&s->pb);
@ -57,8 +59,8 @@ void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
put_bits(&s->pb, 20, 0x10); /* PSC */
temp_ref= s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
(1001 * (int64_t)s->avctx->time_base.den); //FIXME maybe this should use a timestamp
temp_ref = s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
(1001 * (int64_t)s->avctx->time_base.den); // FIXME maybe this should use a timestamp
put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
put_bits(&s->pb, 1, 0); /* split screen off */
@ -73,7 +75,7 @@ void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
put_bits(&s->pb, 1, 0); /* reserved */
put_bits(&s->pb, 1, 0); /* no PEI */
if(format == 0)
if (format == 0)
h->gob_number = -1;
else
h->gob_number = 0;
@ -83,78 +85,80 @@ void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
/**
* Encode a group of blocks header.
*/
static void h261_encode_gob_header(MpegEncContext * s, int mb_line){
H261Context * h = (H261Context *)s;
if(ff_h261_get_picture_format(s->width, s->height) == 0){
h->gob_number+=2; // QCIF
}
else{
h->gob_number++; // CIF
static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
{
H261Context *h = (H261Context *)s;
if (ff_h261_get_picture_format(s->width, s->height) == 0) {
h->gob_number += 2; // QCIF
} else {
h->gob_number++; // CIF
}
put_bits(&s->pb, 16, 1); /* GBSC */
put_bits(&s->pb, 16, 1); /* GBSC */
put_bits(&s->pb, 4, h->gob_number); /* GN */
put_bits(&s->pb, 5, s->qscale); /* GQUANT */
put_bits(&s->pb, 1, 0); /* no GEI */
h->current_mba = 0;
put_bits(&s->pb, 5, s->qscale); /* GQUANT */
put_bits(&s->pb, 1, 0); /* no GEI */
h->current_mba = 0;
h->previous_mba = 0;
h->current_mv_x=0;
h->current_mv_y=0;
h->current_mv_x = 0;
h->current_mv_y = 0;
}
void ff_h261_reorder_mb_index(MpegEncContext* s){
int index= s->mb_x + s->mb_y*s->mb_width;
void ff_h261_reorder_mb_index(MpegEncContext *s)
{
int index = s->mb_x + s->mb_y * s->mb_width;
if(index % 33 == 0)
h261_encode_gob_header(s,0);
if (index % 33 == 0)
h261_encode_gob_header(s, 0);
/* for CIF the GOB's are fragmented in the middle of a scanline
that's why we need to adjust the x and y index of the macroblocks */
if(ff_h261_get_picture_format(s->width,s->height) == 1){ // CIF
s->mb_x = index % 11 ; index /= 11;
s->mb_y = index % 3 ; index /= 3;
s->mb_x+= 11*(index % 2); index /= 2;
s->mb_y+= 3*index;
* that's why we need to adjust the x and y index of the macroblocks */
if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
s->mb_x = index % 11;
index /= 11;
s->mb_y = index % 3;
index /= 3;
s->mb_x += 11 * (index % 2);
index /= 2;
s->mb_y += 3 * index;
ff_init_block_index(s);
ff_update_block_index(s);
}
}
static void h261_encode_motion(H261Context * h, int val){
MpegEncContext * const s = &h->s;
static void h261_encode_motion(H261Context *h, int val)
{
MpegEncContext *const s = &h->s;
int sign, code;
if(val==0){
if (val == 0) {
code = 0;
put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
}
else{
if(val > 15)
val -=32;
if(val < -16)
val+=32;
put_bits(&s->pb, h261_mv_tab[code][1], h261_mv_tab[code][0]);
} else {
if (val > 15)
val -= 32;
if (val < -16)
val += 32;
sign = val < 0;
code = sign ? -val : val;
put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
put_bits(&s->pb,1,sign);
put_bits(&s->pb, h261_mv_tab[code][1], h261_mv_tab[code][0]);
put_bits(&s->pb, 1, sign);
}
}
static inline int get_cbp(MpegEncContext * s,
int16_t block[6][64])
static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
{
int i, cbp;
cbp= 0;
for (i = 0; i < 6; i++) {
cbp = 0;
for (i = 0; i < 6; i++)
if (s->block_last_index[i] >= 0)
cbp |= 1 << (5 - i);
}
return cbp;
}
void ff_h261_encode_mb(MpegEncContext * s,
int16_t block[6][64],
int motion_x, int motion_y)
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
int motion_x, int motion_y)
{
H261Context * h = (H261Context *)s;
H261Context *h = (H261Context *)s;
int mvd, mv_diff_x, mv_diff_y, i, cbp;
cbp = 63; // avoid warning
mvd = 0;
@ -162,77 +166,79 @@ void ff_h261_encode_mb(MpegEncContext * s,
h->current_mba++;
h->mtype = 0;
if (!s->mb_intra){
if (!s->mb_intra) {
/* compute cbp */
cbp= get_cbp(s, block);
cbp = get_cbp(s, block);
/* mvd indicates if this block is motion compensated */
mvd = motion_x | motion_y;
if((cbp | mvd | s->dquant ) == 0) {
if ((cbp | mvd | s->dquant) == 0) {
/* skip macroblock */
s->skip_count++;
h->current_mv_x=0;
h->current_mv_y=0;
h->current_mv_x = 0;
h->current_mv_y = 0;
return;
}
}
/* MB is not skipped, encode MBA */
put_bits(&s->pb, h261_mba_bits[(h->current_mba-h->previous_mba)-1], h261_mba_code[(h->current_mba-h->previous_mba)-1]);
put_bits(&s->pb, h261_mba_bits[(h->current_mba - h->previous_mba) - 1],
h261_mba_code[(h->current_mba - h->previous_mba) - 1]);
/* calculate MTYPE */
if(!s->mb_intra){
if (!s->mb_intra) {
h->mtype++;
if(mvd || s->loop_filter)
h->mtype+=3;
if(s->loop_filter)
h->mtype+=3;
if(cbp || s->dquant)
if (mvd || s->loop_filter)
h->mtype += 3;
if (s->loop_filter)
h->mtype += 3;
if (cbp || s->dquant)
h->mtype++;
assert(h->mtype > 1);
}
if(s->dquant)
if (s->dquant)
h->mtype++;
put_bits(&s->pb, h261_mtype_bits[h->mtype], h261_mtype_code[h->mtype]);
h->mtype = h261_mtype_map[h->mtype];
if(IS_QUANT(h->mtype)){
ff_set_qscale(s,s->qscale+s->dquant);
if (IS_QUANT(h->mtype)) {
ff_set_qscale(s, s->qscale + s->dquant);
put_bits(&s->pb, 5, s->qscale);
}
if(IS_16X16(h->mtype)){
mv_diff_x = (motion_x >> 1) - h->current_mv_x;
mv_diff_y = (motion_y >> 1) - h->current_mv_y;
if (IS_16X16(h->mtype)) {
mv_diff_x = (motion_x >> 1) - h->current_mv_x;
mv_diff_y = (motion_y >> 1) - h->current_mv_y;
h->current_mv_x = (motion_x >> 1);
h->current_mv_y = (motion_y >> 1);
h261_encode_motion(h,mv_diff_x);
h261_encode_motion(h,mv_diff_y);
h261_encode_motion(h, mv_diff_x);
h261_encode_motion(h, mv_diff_y);
}
h->previous_mba = h->current_mba;
if(HAS_CBP(h->mtype)){
assert(cbp>0);
put_bits(&s->pb,h261_cbp_tab[cbp-1][1],h261_cbp_tab[cbp-1][0]);
if (HAS_CBP(h->mtype)) {
assert(cbp > 0);
put_bits(&s->pb, h261_cbp_tab[cbp - 1][1], h261_cbp_tab[cbp - 1][0]);
}
for(i=0; i<6; i++) {
for (i = 0; i < 6; i++)
/* encode each block */
h261_encode_block(h, block[i], i);
}
if ( ( h->current_mba == 11 ) || ( h->current_mba == 22 ) || ( h->current_mba == 33 ) || ( !IS_16X16 ( h->mtype ) )){
h->current_mv_x=0;
h->current_mv_y=0;
if ((h->current_mba == 11) || (h->current_mba == 22) ||
(h->current_mba == 33) || (!IS_16X16(h->mtype))) {
h->current_mv_x = 0;
h->current_mv_y = 0;
}
}
void ff_h261_encode_init(MpegEncContext *s){
void ff_h261_encode_init(MpegEncContext *s)
{
static int done = 0;
if (!done) {
@ -240,20 +246,20 @@ void ff_h261_encode_init(MpegEncContext *s){
ff_init_rl(&h261_rl_tcoeff, ff_h261_rl_table_store);
}
s->min_qcoeff= -127;
s->max_qcoeff= 127;
s->y_dc_scale_table=
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
s->min_qcoeff = -127;
s->max_qcoeff = 127;
s->y_dc_scale_table =
s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
}
/**
* Encode an 8x8 block.
* @param block the 8x8 block
* @param n block index (0-3 are luma, 4-5 are chroma)
*/
static void h261_encode_block(H261Context * h, int16_t * block, int n){
MpegEncContext * const s = &h->s;
static void h261_encode_block(H261Context *h, int16_t *block, int n)
{
MpegEncContext *const s = &h->s;
int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
RLTable *rl;
@ -263,12 +269,12 @@ static void h261_encode_block(H261Context * h, int16_t * block, int n){
level = block[0];
/* 255 cannot be represented, so we clamp */
if (level > 254) {
level = 254;
level = 254;
block[0] = 254;
}
/* 0 cannot be represented also */
else if (level < 1) {
level = 1;
level = 1;
block[0] = 1;
}
if (level == 128)
@ -276,31 +282,33 @@ static void h261_encode_block(H261Context * h, int16_t * block, int n){
else
put_bits(&s->pb, 8, level);
i = 1;
} else if((block[0]==1 || block[0] == -1) && (s->block_last_index[n] > -1)){
//special case
put_bits(&s->pb,2,block[0]>0 ? 2 : 3 );
} else if ((block[0] == 1 || block[0] == -1) &&
(s->block_last_index[n] > -1)) {
// special case
put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
i = 1;
} else {
i = 0;
}
/* AC coefs */
last_index = s->block_last_index[n];
last_index = s->block_last_index[n];
last_non_zero = i - 1;
for (; i <= last_index; i++) {
j = s->intra_scantable.permutated[i];
j = s->intra_scantable.permutated[i];
level = block[j];
if (level) {
run = i - last_non_zero - 1;
sign = 0;
run = i - last_non_zero - 1;
sign = 0;
slevel = level;
if (level < 0) {
sign = 1;
sign = 1;
level = -level;
}
code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/, run, level);
if(run==0 && level < 16)
code+=1;
code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
run, level);
if (run == 0 && level < 16)
code += 1;
put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
if (code == rl->n) {
put_bits(&s->pb, 6, run);
@ -313,9 +321,8 @@ static void h261_encode_block(H261Context * h, int16_t * block, int n){
last_non_zero = i;
}
}
if(last_index > -1){
put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]);// END OF BLOCK
}
if (last_index > -1)
put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
}
FF_MPV_GENERIC_CLASS(h261)
@ -328,7 +335,8 @@ AVCodec ff_h261_encoder = {
.init = ff_MPV_encode_init,
.encode2 = ff_MPV_encode_picture,
.close = ff_MPV_encode_end,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("H.261"),
.priv_class = &h261_class,
};

Write Preview
Loading…
Cancel
Save