*/
/**
- * @file libavcodec/vp3.c
+ * @file
* On2 VP3 Video Decoder
*
* VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
#include <stdlib.h>
#include <string.h>
+#include "libavcore/imgutils.h"
#include "avcodec.h"
#include "dsputil.h"
#include "get_bits.h"
typedef struct Vp3Fragment {
int16_t dc;
uint8_t coding_method;
- int8_t motion_x;
- int8_t motion_y;
uint8_t qpi;
} Vp3Fragment;
int theora, theora_tables;
int version;
int width, height;
+ int chroma_x_shift, chroma_y_shift;
AVFrame golden_frame;
AVFrame last_frame;
AVFrame current_frame;
DSPContext dsp;
int flipped_image;
int last_slice_end;
+ int skip_loop_filter;
int qps[3];
int nqps;
int fragment_start[3];
int data_offset[3];
+ int8_t (*motion_val[2])[2];
+
ScanTable scantable;
/* tables */
unsigned int hbits;
int entries;
int huff_code_size;
- uint16_t huffman_table[80][32][2];
+ uint32_t huffman_table[80][32][2];
uint8_t filter_limit_values[64];
DECLARE_ALIGNED(8, int, bounding_values_array)[256+2];
* superblocks <-> fragments, macroblocks <-> fragments,
* superblocks <-> macroblocks
*
- * Returns 0 is successful; returns 1 if *anything* went wrong.
+ * @return 0 is successful; returns 1 if *anything* went wrong.
*/
static int init_block_mapping(Vp3DecodeContext *s)
{
} else {
/* unpack the list of partially-coded superblocks */
- bit = get_bits1(gb);
- while (current_superblock < s->superblock_count) {
+ bit = get_bits1(gb) ^ 1;
+ current_run = 0;
+
+ while (current_superblock < s->superblock_count && get_bits_left(gb) > 0) {
+ if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
+ bit = get_bits1(gb);
+ else
+ bit ^= 1;
+
current_run = get_vlc2(gb,
s->superblock_run_length_vlc.table, 6, 2) + 1;
if (current_run == 34)
current_superblock += current_run;
if (bit)
num_partial_superblocks += current_run;
-
- if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
- bit = get_bits1(gb);
- else
- bit ^= 1;
}
/* unpack the list of fully coded superblocks if any of the blocks were
int superblocks_decoded = 0;
current_superblock = 0;
- bit = get_bits1(gb);
- while (superblocks_decoded < s->superblock_count - num_partial_superblocks) {
+ bit = get_bits1(gb) ^ 1;
+ current_run = 0;
+
+ while (superblocks_decoded < s->superblock_count - num_partial_superblocks
+ && get_bits_left(gb) > 0) {
+
+ if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
+ bit = get_bits1(gb);
+ else
+ bit ^= 1;
+
current_run = get_vlc2(gb,
s->superblock_run_length_vlc.table, 6, 2) + 1;
if (current_run == 34)
}
}
superblocks_decoded += current_run;
-
- if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
- bit = get_bits1(gb);
- else
- bit ^= 1;
}
}
int sb_end = sb_start + (plane ? s->c_superblock_count : s->y_superblock_count);
int num_coded_frags = 0;
- for (i = sb_start; i < sb_end; i++) {
+ for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {
/* iterate through all 16 fragments in a superblock */
for (j = 0; j < 16; j++) {
/* if the fragment is in bounds, check its coding status */
current_fragment = s->superblock_fragments[i * 16 + j];
- if (current_fragment >= s->fragment_count) {
- av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
- current_fragment, s->fragment_count);
- return 1;
- }
if (current_fragment != -1) {
int coded = s->superblock_coding[i];
int coding_mode;
int custom_mode_alphabet[CODING_MODE_COUNT];
const int *alphabet;
+ Vp3Fragment *frag;
if (s->keyframe) {
for (i = 0; i < s->fragment_count; i++)
* coded fragments */
for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {
for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {
+ if (get_bits_left(gb) <= 0)
+ return -1;
for (j = 0; j < 4; j++) {
int mb_x = 2*sb_x + (j>>1);
s->macroblock_coding[current_macroblock] = coding_mode;
for (k = 0; k < 4; k++) {
- current_fragment =
- BLOCK_Y*s->fragment_width[0] + BLOCK_X;
- if (s->all_fragments[current_fragment].coding_method !=
- MODE_COPY)
- s->all_fragments[current_fragment].coding_method =
- coding_mode;
+ frag = s->all_fragments + BLOCK_Y*s->fragment_width[0] + BLOCK_X;
+ if (frag->coding_method != MODE_COPY)
+ frag->coding_method = coding_mode;
}
- for (k = 0; k < 2; k++) {
- current_fragment = s->fragment_start[k+1] +
- mb_y*s->fragment_width[1] + mb_x;
- if (s->all_fragments[current_fragment].coding_method !=
- MODE_COPY)
- s->all_fragments[current_fragment].coding_method =
- coding_mode;
+
+#define SET_CHROMA_MODES \
+ if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \
+ frag[s->fragment_start[1]].coding_method = coding_mode;\
+ if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \
+ frag[s->fragment_start[2]].coding_method = coding_mode;
+
+ if (s->chroma_y_shift) {
+ frag = s->all_fragments + mb_y*s->fragment_width[1] + mb_x;
+ SET_CHROMA_MODES
+ } else if (s->chroma_x_shift) {
+ frag = s->all_fragments + 2*mb_y*s->fragment_width[1] + mb_x;
+ for (k = 0; k < 2; k++) {
+ SET_CHROMA_MODES
+ frag += s->fragment_width[1];
+ }
+ } else {
+ for (k = 0; k < 4; k++) {
+ frag = s->all_fragments + BLOCK_Y*s->fragment_width[1] + BLOCK_X;
+ SET_CHROMA_MODES
+ }
}
}
}
int prior_last_motion_y = 0;
int current_macroblock;
int current_fragment;
+ int frag;
if (s->keyframe)
return 0;
* coded fragments */
for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {
for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {
+ if (get_bits_left(gb) <= 0)
+ return -1;
for (j = 0; j < 4; j++) {
int mb_x = 2*sb_x + (j>>1);
current_fragment =
BLOCK_Y*s->fragment_width[0] + BLOCK_X;
if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
- s->all_fragments[current_fragment].motion_x = motion_x[k];
- s->all_fragments[current_fragment].motion_y = motion_y[k];
+ s->motion_val[0][current_fragment][0] = motion_x[k];
+ s->motion_val[0][current_fragment][1] = motion_y[k];
} else {
- s->all_fragments[current_fragment].motion_x = motion_x[0];
- s->all_fragments[current_fragment].motion_y = motion_y[0];
+ s->motion_val[0][current_fragment][0] = motion_x[0];
+ s->motion_val[0][current_fragment][1] = motion_y[0];
}
}
+
+ if (s->chroma_y_shift) {
if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
motion_x[0] = RSHIFT(motion_x[0] + motion_x[1] + motion_x[2] + motion_x[3], 2);
motion_y[0] = RSHIFT(motion_y[0] + motion_y[1] + motion_y[2] + motion_y[3], 2);
}
- for (k = 0; k < 2; k++) {
- current_fragment = s->fragment_start[k+1] +
- mb_y*s->fragment_width[1] + mb_x;
- s->all_fragments[current_fragment].motion_x = motion_x[0];
- s->all_fragments[current_fragment].motion_y = motion_y[0];
+ motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1);
+ motion_y[0] = (motion_y[0]>>1) | (motion_y[0]&1);
+ frag = mb_y*s->fragment_width[1] + mb_x;
+ s->motion_val[1][frag][0] = motion_x[0];
+ s->motion_val[1][frag][1] = motion_y[0];
+ } else if (s->chroma_x_shift) {
+ if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
+ motion_x[0] = RSHIFT(motion_x[0] + motion_x[1], 1);
+ motion_y[0] = RSHIFT(motion_y[0] + motion_y[1], 1);
+ motion_x[1] = RSHIFT(motion_x[2] + motion_x[3], 1);
+ motion_y[1] = RSHIFT(motion_y[2] + motion_y[3], 1);
+ } else {
+ motion_x[1] = motion_x[0];
+ motion_y[1] = motion_y[0];
+ }
+ motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1);
+ motion_x[1] = (motion_x[1]>>1) | (motion_x[1]&1);
+
+ frag = 2*mb_y*s->fragment_width[1] + mb_x;
+ for (k = 0; k < 2; k++) {
+ s->motion_val[1][frag][0] = motion_x[k];
+ s->motion_val[1][frag][1] = motion_y[k];
+ frag += s->fragment_width[1];
+ }
+ } else {
+ for (k = 0; k < 4; k++) {
+ frag = BLOCK_Y*s->fragment_width[1] + BLOCK_X;
+ if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
+ s->motion_val[1][frag][0] = motion_x[k];
+ s->motion_val[1][frag][1] = motion_y[k];
+ } else {
+ s->motion_val[1][frag][0] = motion_x[0];
+ s->motion_val[1][frag][1] = motion_y[0];
+ }
+ }
}
}
}
for (qpi = 0; qpi < s->nqps-1 && num_blocks > 0; qpi++) {
i = blocks_decoded = num_blocks_at_qpi = 0;
- bit = get_bits1(gb);
+ bit = get_bits1(gb) ^ 1;
+ run_length = 0;
do {
+ if (run_length == MAXIMUM_LONG_BIT_RUN)
+ bit = get_bits1(gb);
+ else
+ bit ^= 1;
+
run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1;
if (run_length == 34)
run_length += get_bits(gb, 12);
j++;
}
}
-
- if (run_length == MAXIMUM_LONG_BIT_RUN)
- bit = get_bits1(gb);
- else
- bit ^= 1;
- } while (blocks_decoded < num_blocks);
+ } while (blocks_decoded < num_blocks && get_bits_left(gb) > 0);
num_blocks -= num_blocks_at_qpi;
}
while (coeff_i < num_coeffs && get_bits_left(gb) > 0) {
/* decode a VLC into a token */
- token = get_vlc2(gb, vlc_table, 5, 3);
+ token = get_vlc2(gb, vlc_table, 11, 3);
/* use the token to get a zero run, a coefficient, and an eob run */
if (token <= 6) {
eob_run = eob_run_base[token];
}
/**
- * Pulls DCT tokens from the 64 levels to decode and dequant the coefficients
+ * Pull DCT tokens from the 64 levels to decode and dequant the coefficients
* for the next block in coding order
*/
static inline int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag,
block[perm[i]] = (token >> 2) * dequantizer[perm[i]];
s->dct_tokens[plane][i++]++;
break;
- default:
- av_log(s->avctx, AV_LOG_ERROR, "internal: invalid token type\n");
+ default: // shouldn't happen
return i;
}
} while (i < 64);
return;
h= y - s->last_slice_end;
+ s->last_slice_end= y;
y -= h;
if (!s->flipped_image) {
- if (y == 0)
- h -= s->height - s->avctx->height; // account for non-mod16
- y = s->height - y - h;
+ y = s->avctx->height - y - h;
}
- cy = y >> 1;
+ cy = y >> s->chroma_y_shift;
offset[0] = s->current_frame.linesize[0]*y;
offset[1] = s->current_frame.linesize[1]*cy;
offset[2] = s->current_frame.linesize[2]*cy;
emms_c();
s->avctx->draw_horiz_band(s->avctx, &s->current_frame, offset, y, 3, h);
- s->last_slice_end= y + h;
}
/*
uint8_t * last_plane = s-> last_frame.data [plane] + s->data_offset[plane];
uint8_t *golden_plane = s-> golden_frame.data [plane] + s->data_offset[plane];
int stride = s->current_frame.linesize[plane];
- int plane_width = s->width >> !!plane;
- int plane_height = s->height >> !!plane;
+ int plane_width = s->width >> (plane && s->chroma_x_shift);
+ int plane_height = s->height >> (plane && s->chroma_y_shift);
+ int8_t (*motion_val)[2] = s->motion_val[!!plane];
- int sb_x, sb_y = slice << !plane;
- int slice_height = sb_y + (plane ? 1 : 2);
+ int sb_x, sb_y = slice << (!plane && s->chroma_y_shift);
+ int slice_height = sb_y + 1 + (!plane && s->chroma_y_shift);
int slice_width = plane ? s->c_superblock_width : s->y_superblock_width;
int fragment_width = s->fragment_width[!!plane];
/* transform if this block was coded */
if (s->all_fragments[i].coding_method != MODE_COPY) {
- int intra = s->all_fragments[i].coding_method == MODE_INTRA;
-
if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
(s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
motion_source= golden_plane;
if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
(s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
int src_x, src_y;
- motion_x = s->all_fragments[i].motion_x;
- motion_y = s->all_fragments[i].motion_y;
- if(plane){
- motion_x= (motion_x>>1) | (motion_x&1);
- motion_y= (motion_y>>1) | (motion_y&1);
- }
+ motion_x = motion_val[y*fragment_width + x][0];
+ motion_y = motion_val[y*fragment_width + x][1];
src_x= (motion_x>>1) + 8*x;
src_y= (motion_y>>1) + 8*y;
}
s->dsp.clear_block(block);
- vp3_dequant(s, s->all_fragments + i, plane, !intra, block);
/* invert DCT and place (or add) in final output */
if (s->all_fragments[i].coding_method == MODE_INTRA) {
+ vp3_dequant(s, s->all_fragments + i, plane, 0, block);
if(s->avctx->idct_algo!=FF_IDCT_VP3)
block[0] += 128<<3;
s->dsp.idct_put(
stride,
block);
} else {
+ if (vp3_dequant(s, s->all_fragments + i, plane, 1, block)) {
s->dsp.idct_add(
output_plane + first_pixel,
stride,
block);
+ } else {
+ s->dsp.vp3_idct_dc_add(output_plane + first_pixel, stride, block);
+ }
}
} else {
}
// Filter up to the last row in the superblock row
- apply_loop_filter(s, plane, 4*sb_y - !!sb_y, FFMIN(4*sb_y+3, fragment_height-1));
+ if (!s->skip_loop_filter)
+ apply_loop_filter(s, plane, 4*sb_y - !!sb_y, FFMIN(4*sb_y+3, fragment_height-1));
}
}
* dispatch (slice - 1);
*/
- vp3_draw_horiz_band(s, FFMIN(64*slice + 64-16, s->height-16));
+ vp3_draw_horiz_band(s, FFMIN((32 << s->chroma_y_shift) * (slice + 1) -16, s->height-16));
}
/*
int i, inter, plane;
int c_width;
int c_height;
+ int y_fragment_count, c_fragment_count;
if (avctx->codec_tag == MKTAG('V','P','3','0'))
s->version = 0;
s->avctx = avctx;
s->width = FFALIGN(avctx->width, 16);
s->height = FFALIGN(avctx->height, 16);
- avctx->pix_fmt = PIX_FMT_YUV420P;
+ if (avctx->pix_fmt == PIX_FMT_NONE)
+ avctx->pix_fmt = PIX_FMT_YUV420P;
avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
if(avctx->idct_algo==FF_IDCT_AUTO)
avctx->idct_algo=FF_IDCT_VP3;
for (i = 0; i < 3; i++)
s->qps[i] = -1;
+ avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
+
s->y_superblock_width = (s->width + 31) / 32;
s->y_superblock_height = (s->height + 31) / 32;
s->y_superblock_count = s->y_superblock_width * s->y_superblock_height;
/* work out the dimensions for the C planes */
- c_width = s->width / 2;
- c_height = s->height / 2;
+ c_width = s->width >> s->chroma_x_shift;
+ c_height = s->height >> s->chroma_y_shift;
s->c_superblock_width = (c_width + 31) / 32;
s->c_superblock_height = (c_height + 31) / 32;
s->c_superblock_count = s->c_superblock_width * s->c_superblock_height;
s->fragment_width[0] = s->width / FRAGMENT_PIXELS;
s->fragment_height[0] = s->height / FRAGMENT_PIXELS;
- s->fragment_width[1] = s->fragment_width[0] >> 1;
- s->fragment_height[1] = s->fragment_height[0] >> 1;
+ s->fragment_width[1] = s->fragment_width[0] >> s->chroma_x_shift;
+ s->fragment_height[1] = s->fragment_height[0] >> s->chroma_y_shift;
/* fragment count covers all 8x8 blocks for all 3 planes */
- s->fragment_count = s->fragment_width[0] * s->fragment_height[0] * 3 / 2;
- s->fragment_start[1] = s->fragment_width[0] * s->fragment_height[0];
- s->fragment_start[2] = s->fragment_width[0] * s->fragment_height[0] * 5 / 4;
+ y_fragment_count = s->fragment_width[0] * s->fragment_height[0];
+ c_fragment_count = s->fragment_width[1] * s->fragment_height[1];
+ s->fragment_count = y_fragment_count + 2*c_fragment_count;
+ s->fragment_start[1] = y_fragment_count;
+ s->fragment_start[2] = y_fragment_count + c_fragment_count;
s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
s->coded_fragment_list[0] = av_malloc(s->fragment_count * sizeof(int));
s->dct_tokens_base = av_malloc(64*s->fragment_count * sizeof(*s->dct_tokens_base));
+ s->motion_val[0] = av_malloc(y_fragment_count * sizeof(*s->motion_val[0]));
+ s->motion_val[1] = av_malloc(c_fragment_count * sizeof(*s->motion_val[1]));
+
if (!s->superblock_coding || !s->all_fragments || !s->dct_tokens_base ||
- !s->coded_fragment_list[0]) {
+ !s->coded_fragment_list[0] || !s->motion_val[0] || !s->motion_val[1]) {
vp3_decode_end(avctx);
return -1;
}
for (i = 0; i < 16; i++) {
/* DC histograms */
- init_vlc(&s->dc_vlc[i], 5, 32,
+ init_vlc(&s->dc_vlc[i], 11, 32,
&dc_bias[i][0][1], 4, 2,
&dc_bias[i][0][0], 4, 2, 0);
/* group 1 AC histograms */
- init_vlc(&s->ac_vlc_1[i], 5, 32,
+ init_vlc(&s->ac_vlc_1[i], 11, 32,
&ac_bias_0[i][0][1], 4, 2,
&ac_bias_0[i][0][0], 4, 2, 0);
/* group 2 AC histograms */
- init_vlc(&s->ac_vlc_2[i], 5, 32,
+ init_vlc(&s->ac_vlc_2[i], 11, 32,
&ac_bias_1[i][0][1], 4, 2,
&ac_bias_1[i][0][0], 4, 2, 0);
/* group 3 AC histograms */
- init_vlc(&s->ac_vlc_3[i], 5, 32,
+ init_vlc(&s->ac_vlc_3[i], 11, 32,
&ac_bias_2[i][0][1], 4, 2,
&ac_bias_2[i][0][0], 4, 2, 0);
/* group 4 AC histograms */
- init_vlc(&s->ac_vlc_4[i], 5, 32,
+ init_vlc(&s->ac_vlc_4[i], 11, 32,
&ac_bias_3[i][0][1], 4, 2,
&ac_bias_3[i][0][0], 4, 2, 0);
}
} else {
- for (i = 0; i < 16; i++) {
+ for (i = 0; i < 16; i++) {
/* DC histograms */
- if (init_vlc(&s->dc_vlc[i], 5, 32,
- &s->huffman_table[i][0][1], 4, 2,
- &s->huffman_table[i][0][0], 4, 2, 0) < 0)
+ if (init_vlc(&s->dc_vlc[i], 11, 32,
+ &s->huffman_table[i][0][1], 8, 4,
+ &s->huffman_table[i][0][0], 8, 4, 0) < 0)
goto vlc_fail;
/* group 1 AC histograms */
- if (init_vlc(&s->ac_vlc_1[i], 5, 32,
- &s->huffman_table[i+16][0][1], 4, 2,
- &s->huffman_table[i+16][0][0], 4, 2, 0) < 0)
+ if (init_vlc(&s->ac_vlc_1[i], 11, 32,
+ &s->huffman_table[i+16][0][1], 8, 4,
+ &s->huffman_table[i+16][0][0], 8, 4, 0) < 0)
goto vlc_fail;
/* group 2 AC histograms */
- if (init_vlc(&s->ac_vlc_2[i], 5, 32,
- &s->huffman_table[i+16*2][0][1], 4, 2,
- &s->huffman_table[i+16*2][0][0], 4, 2, 0) < 0)
+ if (init_vlc(&s->ac_vlc_2[i], 11, 32,
+ &s->huffman_table[i+16*2][0][1], 8, 4,
+ &s->huffman_table[i+16*2][0][0], 8, 4, 0) < 0)
goto vlc_fail;
/* group 3 AC histograms */
- if (init_vlc(&s->ac_vlc_3[i], 5, 32,
- &s->huffman_table[i+16*3][0][1], 4, 2,
- &s->huffman_table[i+16*3][0][0], 4, 2, 0) < 0)
+ if (init_vlc(&s->ac_vlc_3[i], 11, 32,
+ &s->huffman_table[i+16*3][0][1], 8, 4,
+ &s->huffman_table[i+16*3][0][0], 8, 4, 0) < 0)
goto vlc_fail;
/* group 4 AC histograms */
- if (init_vlc(&s->ac_vlc_4[i], 5, 32,
- &s->huffman_table[i+16*4][0][1], 4, 2,
- &s->huffman_table[i+16*4][0][0], 4, 2, 0) < 0)
+ if (init_vlc(&s->ac_vlc_4[i], 11, 32,
+ &s->huffman_table[i+16*4][0][1], 8, 4,
+ &s->huffman_table[i+16*4][0][0], 8, 4, 0) < 0)
goto vlc_fail;
}
}
s->keyframe?"key":"", counter, s->qps[0]);
counter++;
+ s->skip_loop_filter = !s->filter_limit_values[s->qps[0]] ||
+ avctx->skip_loop_filter >= (s->keyframe ? AVDISCARD_ALL : AVDISCARD_NONKEY);
+
if (s->qps[0] != s->last_qps[0])
init_loop_filter(s);
}
for (i = 0; i < 3; i++) {
+ int height = s->height >> (i && s->chroma_y_shift);
if (s->flipped_image)
s->data_offset[i] = 0;
else
- s->data_offset[i] = ((s->height>>!!i)-1) * s->current_frame.linesize[i];
+ s->data_offset[i] = (height-1) * s->current_frame.linesize[i];
}
s->last_slice_end = 0;
// filter the last row
for (i = 0; i < 3; i++) {
- int row = (s->height >> (3+!!i)) - 1;
+ int row = (s->height >> (3+(i && s->chroma_y_shift))) - 1;
apply_loop_filter(s, i, row, row+1);
}
- vp3_draw_horiz_band(s, s->height);
+ vp3_draw_horiz_band(s, s->avctx->height);
*data_size=sizeof(AVFrame);
*(AVFrame*)data= s->current_frame;
av_free(s->dct_tokens_base);
av_free(s->superblock_fragments);
av_free(s->macroblock_coding);
+ av_free(s->motion_val[0]);
+ av_free(s->motion_val[1]);
for (i = 0; i < 16; i++) {
free_vlc(&s->dc_vlc[i]);
}
#if CONFIG_THEORA_DECODER
+static const enum PixelFormat theora_pix_fmts[4] = {
+ PIX_FMT_YUV420P, PIX_FMT_NONE, PIX_FMT_YUV422P, PIX_FMT_YUV444P
+};
+
static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
{
Vp3DecodeContext *s = avctx->priv_data;
int visible_width, visible_height, colorspace;
+ int offset_x = 0, offset_y = 0;
+ AVRational fps, aspect;
s->theora = get_bits_long(gb, 24);
av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);
visible_width = s->width = get_bits(gb, 16) << 4;
visible_height = s->height = get_bits(gb, 16) << 4;
- if(avcodec_check_dimensions(avctx, s->width, s->height)){
+ if(av_image_check_size(s->width, s->height, 0, avctx)){
av_log(avctx, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n", s->width, s->height);
s->width= s->height= 0;
return -1;
visible_width = get_bits_long(gb, 24);
visible_height = get_bits_long(gb, 24);
- skip_bits(gb, 8); /* offset x */
- skip_bits(gb, 8); /* offset y */
+ offset_x = get_bits(gb, 8); /* offset x */
+ offset_y = get_bits(gb, 8); /* offset y, from bottom */
}
- skip_bits(gb, 32); /* fps numerator */
- skip_bits(gb, 32); /* fps denumerator */
- skip_bits(gb, 24); /* aspect numerator */
- skip_bits(gb, 24); /* aspect denumerator */
+ fps.num = get_bits_long(gb, 32);
+ fps.den = get_bits_long(gb, 32);
+ if (fps.num && fps.den) {
+ av_reduce(&avctx->time_base.num, &avctx->time_base.den,
+ fps.den, fps.num, 1<<30);
+ }
+
+ aspect.num = get_bits_long(gb, 24);
+ aspect.den = get_bits_long(gb, 24);
+ if (aspect.num && aspect.den) {
+ av_reduce(&avctx->sample_aspect_ratio.num,
+ &avctx->sample_aspect_ratio.den,
+ aspect.num, aspect.den, 1<<30);
+ }
if (s->theora < 0x030200)
skip_bits(gb, 5); /* keyframe frequency force */
if (s->theora >= 0x030200)
{
skip_bits(gb, 5); /* keyframe frequency force */
- skip_bits(gb, 2); /* pixel format: 420,res,422,444 */
+ avctx->pix_fmt = theora_pix_fmts[get_bits(gb, 2)];
skip_bits(gb, 3); /* reserved */
}
// align_get_bits(gb);
if ( visible_width <= s->width && visible_width > s->width-16
- && visible_height <= s->height && visible_height > s->height-16)
+ && visible_height <= s->height && visible_height > s->height-16
+ && !offset_x && (offset_y == s->height - visible_height))
avcodec_set_dimensions(avctx, visible_width, visible_height);
else
avcodec_set_dimensions(avctx, s->width, s->height);
if (s->theora >= 0x030200) {
n = get_bits(gb, 3);
/* loop filter limit values table */
- for (i = 0; i < 64; i++) {
- s->filter_limit_values[i] = get_bits(gb, n);
- if (s->filter_limit_values[i] > 127) {
- av_log(avctx, AV_LOG_ERROR, "filter limit value too large (%i > 127), clamping\n", s->filter_limit_values[i]);
- s->filter_limit_values[i] = 127;
- }
- }
+ if (n)
+ for (i = 0; i < 64; i++)
+ s->filter_limit_values[i] = get_bits(gb, n);
}
if (s->theora >= 0x030200)
AVCodec theora_decoder = {
"theora",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_THEORA,
sizeof(Vp3DecodeContext),
theora_decode_init,
AVCodec vp3_decoder = {
"vp3",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP3,
sizeof(Vp3DecodeContext),
vp3_decode_init,