← Back to branch summary

~ppsspp/ppsspp/ffmpeg

« back to all changes in this revision

Viewing changes to libavcodec/mjpegenc.c

  • Committer: Henrik Rydgård
  • Date: 2014-01-03 10:44:32 UTC
  • Revision ID: git-v1:87c6c126784b1718bfa448ecf2e6a9fef781eb4e
Update our ffmpeg snapshot to a clone of the official repository.

This is because Maxim's at3plus support has been officially merged!

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/mjpegenc.c
30
30
 * MJPEG encoder.
31
31
 */
32
32
 
 
33
#include "libavutil/pixdesc.h"
 
34
 
33
35
#include "avcodec.h"
34
36
#include "mpegvideo.h"
35
37
#include "mjpeg.h"
46
48
 
47
49
    if (s->width > 65500 || s->height > 65500) {
48
50
        av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
49
 
        return -1;
 
51
        return AVERROR(EINVAL);
50
52
    }
51
53
 
52
54
    m = av_malloc(sizeof(MJpegContext));
53
55
    if (!m)
54
 
        return -1;
 
56
        return AVERROR(ENOMEM);
55
57
 
56
58
    s->min_qcoeff=-1023;
57
59
    s->max_qcoeff= 1023;
84
86
}
85
87
 
86
88
/* table_class: 0 = DC coef, 1 = AC coefs */
87
 
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 
89
static int put_huffman_table(PutBitContext *p, int table_class, int table_id,
88
90
                             const uint8_t *bits_table, const uint8_t *value_table)
89
91
{
90
 
    PutBitContext *p = &s->pb;
91
92
    int n, i;
92
93
 
93
94
    put_bits(p, 4, table_class);
105
106
    return n + 17;
106
107
}
107
108
 
108
 
static void jpeg_table_header(MpegEncContext *s)
 
109
static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p,
 
110
                              ScanTable *intra_scantable,
 
111
                              uint16_t intra_matrix[64],
 
112
                              int hsample[3])
109
113
{
110
 
    PutBitContext *p = &s->pb;
111
114
    int i, j, size;
112
115
    uint8_t *ptr;
113
116
 
114
 
    if (s->avctx->codec_id != AV_CODEC_ID_LJPEG) {
 
117
    if (avctx->codec_id != AV_CODEC_ID_LJPEG) {
115
118
    /* quant matrixes */
116
119
    put_marker(p, DQT);
117
120
#ifdef TWOMATRIXES
122
125
    put_bits(p, 4, 0); /* 8 bit precision */
123
126
    put_bits(p, 4, 0); /* table 0 */
124
127
    for(i=0;i<64;i++) {
125
 
        j = s->intra_scantable.permutated[i];
126
 
        put_bits(p, 8, s->intra_matrix[j]);
 
128
        j = intra_scantable->permutated[i];
 
129
        put_bits(p, 8, intra_matrix[j]);
127
130
    }
128
131
#ifdef TWOMATRIXES
129
132
    put_bits(p, 4, 0); /* 8 bit precision */
135
138
#endif
136
139
    }
137
140
 
138
 
    if(s->avctx->active_thread_type & FF_THREAD_SLICE){
 
141
    if(avctx->active_thread_type & FF_THREAD_SLICE){
139
142
        put_marker(p, DRI);
140
143
        put_bits(p, 16, 4);
141
 
        put_bits(p, 16, (s->width-1)/(8*s->mjpeg_hsample[0]) + 1);
 
144
        put_bits(p, 16, (avctx->width-1)/(8*hsample[0]) + 1);
142
145
    }
143
146
 
144
147
    /* huffman table */
147
150
    ptr = put_bits_ptr(p);
148
151
    put_bits(p, 16, 0); /* patched later */
149
152
    size = 2;
150
 
    size += put_huffman_table(s, 0, 0, avpriv_mjpeg_bits_dc_luminance,
 
153
    size += put_huffman_table(p, 0, 0, avpriv_mjpeg_bits_dc_luminance,
151
154
                              avpriv_mjpeg_val_dc);
152
 
    size += put_huffman_table(s, 0, 1, avpriv_mjpeg_bits_dc_chrominance,
 
155
    size += put_huffman_table(p, 0, 1, avpriv_mjpeg_bits_dc_chrominance,
153
156
                              avpriv_mjpeg_val_dc);
154
157
 
155
 
    size += put_huffman_table(s, 1, 0, avpriv_mjpeg_bits_ac_luminance,
 
158
    size += put_huffman_table(p, 1, 0, avpriv_mjpeg_bits_ac_luminance,
156
159
                              avpriv_mjpeg_val_ac_luminance);
157
 
    size += put_huffman_table(s, 1, 1, avpriv_mjpeg_bits_ac_chrominance,
 
160
    size += put_huffman_table(p, 1, 1, avpriv_mjpeg_bits_ac_chrominance,
158
161
                              avpriv_mjpeg_val_ac_chrominance);
159
162
    AV_WB16(ptr, size);
160
163
}
161
164
 
162
 
static void jpeg_put_comments(MpegEncContext *s)
 
165
static void jpeg_put_comments(AVCodecContext *avctx, PutBitContext *p)
163
166
{
164
 
    PutBitContext *p = &s->pb;
165
167
    int size;
166
168
    uint8_t *ptr;
167
169
 
168
 
    if (s->avctx->sample_aspect_ratio.num /* && !lossless */)
169
 
    {
170
 
    /* JFIF header */
171
 
    put_marker(p, APP0);
172
 
    put_bits(p, 16, 16);
173
 
    avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
174
 
    put_bits(p, 16, 0x0102); /* v 1.02 */
175
 
    put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
176
 
    put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
177
 
    put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
178
 
    put_bits(p, 8, 0); /* thumbnail width */
179
 
    put_bits(p, 8, 0); /* thumbnail height */
 
170
    if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
 
171
        /* JFIF header */
 
172
        put_marker(p, APP0);
 
173
        put_bits(p, 16, 16);
 
174
        avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
 
175
        put_bits(p, 16, 0x0102);         /* v 1.02 */
 
176
        put_bits(p,  8, 0);              /* units type: 0 - aspect ratio */
 
177
        put_bits(p, 16, avctx->sample_aspect_ratio.num);
 
178
        put_bits(p, 16, avctx->sample_aspect_ratio.den);
 
179
        put_bits(p, 8, 0); /* thumbnail width */
 
180
        put_bits(p, 8, 0); /* thumbnail height */
180
181
    }
181
182
 
182
183
    /* comment */
183
 
    if(!(s->flags & CODEC_FLAG_BITEXACT)){
 
184
    if (!(avctx->flags & CODEC_FLAG_BITEXACT)) {
184
185
        put_marker(p, COM);
185
186
        flush_put_bits(p);
186
187
        ptr = put_bits_ptr(p);
190
191
        AV_WB16(ptr, size);
191
192
    }
192
193
 
193
 
    if(  s->avctx->pix_fmt == AV_PIX_FMT_YUV420P
194
 
       ||s->avctx->pix_fmt == AV_PIX_FMT_YUV422P
195
 
       ||s->avctx->pix_fmt == AV_PIX_FMT_YUV444P){
 
194
    if (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
 
195
        avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
 
196
        avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
196
197
        put_marker(p, COM);
197
198
        flush_put_bits(p);
198
199
        ptr = put_bits_ptr(p);
203
204
    }
204
205
}
205
206
 
206
 
void ff_mjpeg_encode_picture_header(MpegEncContext *s)
207
 
{
208
 
    const int lossless= s->avctx->codec_id != AV_CODEC_ID_MJPEG;
 
207
void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[3], int vsample[3])
 
208
{
 
209
    int chroma_h_shift, chroma_v_shift;
 
210
 
 
211
    av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
 
212
                                     &chroma_v_shift);
 
213
    if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
 
214
        (   avctx->pix_fmt == AV_PIX_FMT_BGR0
 
215
         || avctx->pix_fmt == AV_PIX_FMT_BGRA
 
216
         || avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
 
217
        vsample[0] = hsample[0] =
 
218
        vsample[1] = hsample[1] =
 
219
        vsample[2] = hsample[2] = 1;
 
220
    } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
 
221
        vsample[0] = vsample[1] = vsample[2] = 2;
 
222
        hsample[0] = hsample[1] = hsample[2] = 1;
 
223
    } else {
 
224
        vsample[0] = 2;
 
225
        vsample[1] = 2 >> chroma_v_shift;
 
226
        vsample[2] = 2 >> chroma_v_shift;
 
227
        hsample[0] = 2;
 
228
        hsample[1] = 2 >> chroma_h_shift;
 
229
        hsample[2] = 2 >> chroma_h_shift;
 
230
    }
 
231
}
 
232
 
 
233
void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb,
 
234
                                    ScanTable *intra_scantable,
 
235
                                    uint16_t intra_matrix[64])
 
236
{
 
237
    const int lossless = avctx->codec_id != AV_CODEC_ID_MJPEG && avctx->codec_id != AV_CODEC_ID_AMV;
 
238
    int hsample[3], vsample[3];
209
239
    int i;
210
240
 
211
 
    put_marker(&s->pb, SOI);
 
241
    ff_mjpeg_init_hvsample(avctx, hsample, vsample);
 
242
 
 
243
    put_marker(pb, SOI);
212
244
 
213
245
    // hack for AMV mjpeg format
214
 
    if(s->avctx->codec_id == AV_CODEC_ID_AMV) goto end;
215
 
 
216
 
    jpeg_put_comments(s);
217
 
 
218
 
    jpeg_table_header(s);
219
 
 
220
 
    switch(s->avctx->codec_id){
221
 
    case AV_CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;
222
 
    case AV_CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;
 
246
    if(avctx->codec_id == AV_CODEC_ID_AMV) goto end;
 
247
 
 
248
    jpeg_put_comments(avctx, pb);
 
249
 
 
250
    jpeg_table_header(avctx, pb, intra_scantable, intra_matrix, hsample);
 
251
 
 
252
    switch (avctx->codec_id) {
 
253
    case AV_CODEC_ID_MJPEG:  put_marker(pb, SOF0 ); break;
 
254
    case AV_CODEC_ID_LJPEG:  put_marker(pb, SOF3 ); break;
223
255
    default: av_assert0(0);
224
256
    }
225
257
 
226
 
    put_bits(&s->pb, 16, 17);
227
 
    if(lossless && (s->avctx->pix_fmt == AV_PIX_FMT_BGR0
228
 
                    || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
229
 
                    || s->avctx->pix_fmt == AV_PIX_FMT_BGR24))
230
 
        put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
 
258
    put_bits(pb, 16, 17);
 
259
    if (lossless && (  avctx->pix_fmt == AV_PIX_FMT_BGR0
 
260
                    || avctx->pix_fmt == AV_PIX_FMT_BGRA
 
261
                    || avctx->pix_fmt == AV_PIX_FMT_BGR24))
 
262
        put_bits(pb, 8, 9); /* 9 bits/component RCT */
231
263
    else
232
 
        put_bits(&s->pb, 8, 8); /* 8 bits/component */
233
 
    put_bits(&s->pb, 16, s->height);
234
 
    put_bits(&s->pb, 16, s->width);
235
 
    put_bits(&s->pb, 8, 3); /* 3 components */
 
264
        put_bits(pb, 8, 8); /* 8 bits/component */
 
265
    put_bits(pb, 16, avctx->height);
 
266
    put_bits(pb, 16, avctx->width);
 
267
    put_bits(pb, 8, 3); /* 3 components */
236
268
 
237
269
    /* Y component */
238
 
    put_bits(&s->pb, 8, 1); /* component number */
239
 
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
240
 
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
241
 
    put_bits(&s->pb, 8, 0); /* select matrix */
 
270
    put_bits(pb, 8, 1); /* component number */
 
271
    put_bits(pb, 4, hsample[0]); /* H factor */
 
272
    put_bits(pb, 4, vsample[0]); /* V factor */
 
273
    put_bits(pb, 8, 0); /* select matrix */
242
274
 
243
275
    /* Cb component */
244
 
    put_bits(&s->pb, 8, 2); /* component number */
245
 
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
246
 
    put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
 
276
    put_bits(pb, 8, 2); /* component number */
 
277
    put_bits(pb, 4, hsample[1]); /* H factor */
 
278
    put_bits(pb, 4, vsample[1]); /* V factor */
247
279
#ifdef TWOMATRIXES
248
 
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 
280
    put_bits(pb, 8, lossless ? 0 : 1); /* select matrix */
249
281
#else
250
 
    put_bits(&s->pb, 8, 0); /* select matrix */
 
282
    put_bits(pb, 8, 0); /* select matrix */
251
283
#endif
252
284
 
253
285
    /* Cr component */
254
 
    put_bits(&s->pb, 8, 3); /* component number */
255
 
    put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
256
 
    put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
 
286
    put_bits(pb, 8, 3); /* component number */
 
287
    put_bits(pb, 4, hsample[2]); /* H factor */
 
288
    put_bits(pb, 4, vsample[2]); /* V factor */
257
289
#ifdef TWOMATRIXES
258
 
    put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 
290
    put_bits(pb, 8, lossless ? 0 : 1); /* select matrix */
259
291
#else
260
 
    put_bits(&s->pb, 8, 0); /* select matrix */
 
292
    put_bits(pb, 8, 0); /* select matrix */
261
293
#endif
262
294
 
263
295
    /* scan header */
264
 
    put_marker(&s->pb, SOS);
265
 
    put_bits(&s->pb, 16, 12); /* length */
266
 
    put_bits(&s->pb, 8, 3); /* 3 components */
 
296
    put_marker(pb, SOS);
 
297
    put_bits(pb, 16, 12); /* length */
 
298
    put_bits(pb, 8, 3); /* 3 components */
267
299
 
268
300
    /* Y component */
269
 
    put_bits(&s->pb, 8, 1); /* index */
270
 
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
271
 
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
 
301
    put_bits(pb, 8, 1); /* index */
 
302
    put_bits(pb, 4, 0); /* DC huffman table index */
 
303
    put_bits(pb, 4, 0); /* AC huffman table index */
272
304
 
273
305
    /* Cb component */
274
 
    put_bits(&s->pb, 8, 2); /* index */
275
 
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
276
 
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 
306
    put_bits(pb, 8, 2); /* index */
 
307
    put_bits(pb, 4, 1); /* DC huffman table index */
 
308
    put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
277
309
 
278
310
    /* Cr component */
279
 
    put_bits(&s->pb, 8, 3); /* index */
280
 
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
281
 
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
282
 
 
283
 
    put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
284
 
 
285
 
    switch(s->avctx->codec_id){
286
 
    case AV_CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */
287
 
    case AV_CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */
 
311
    put_bits(pb, 8, 3); /* index */
 
312
    put_bits(pb, 4, 1); /* DC huffman table index */
 
313
    put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 
314
 
 
315
    put_bits(pb, 8, lossless ? avctx->prediction_method + 1 : 0); /* Ss (not used) */
 
316
 
 
317
    switch (avctx->codec_id) {
 
318
    case AV_CODEC_ID_MJPEG:  put_bits(pb, 8, 63); break; /* Se (not used) */
 
319
    case AV_CODEC_ID_LJPEG:  put_bits(pb, 8,  0); break; /* not used */
288
320
    default: av_assert0(0);
289
321
    }
290
322
 
291
 
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
 
323
    put_bits(pb, 8, 0); /* Ah/Al (not used) */
292
324
 
293
325
end:
294
 
    s->esc_pos = put_bits_count(&s->pb) >> 3;
295
 
    for(i=1; i<s->slice_context_count; i++)
296
 
        s->thread_context[i]->esc_pos = 0;
 
326
    if (!lossless) {
 
327
        MpegEncContext *s = avctx->priv_data;
 
328
        av_assert0(avctx->codec->priv_data_size == sizeof(MpegEncContext));
 
329
 
 
330
        s->esc_pos = put_bits_count(pb) >> 3;
 
331
        for(i=1; i<s->slice_context_count; i++)
 
332
            s->thread_context[i]->esc_pos = 0;
 
333
    }
297
334
}
298
335
 
299
 
static void escape_FF(MpegEncContext *s, int start)
 
336
void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
300
337
{
301
 
    int size= put_bits_count(&s->pb) - start*8;
 
338
    int size;
302
339
    int i, ff_count;
303
 
    uint8_t *buf= s->pb.buf + start;
 
340
    uint8_t *buf = pb->buf + start;
304
341
    int align= (-(size_t)(buf))&3;
 
342
    int pad = (-put_bits_count(pb))&7;
 
343
 
 
344
    if (pad)
 
345
        put_bits(pb, pad, (1<<pad)-1);
 
346
 
 
347
    flush_put_bits(pb);
 
348
    size = put_bits_count(pb) - start * 8;
305
349
 
306
350
    av_assert1((size&7) == 0);
307
351
    size >>= 3;
333
377
 
334
378
    if(ff_count==0) return;
335
379
 
336
 
    flush_put_bits(&s->pb);
337
 
    skip_put_bytes(&s->pb, ff_count);
 
380
    flush_put_bits(pb);
 
381
    skip_put_bytes(pb, ff_count);
338
382
 
339
383
    for(i=size-1; ff_count; i--){
340
384
        int v= buf[i];
350
394
 
351
395
void ff_mjpeg_encode_stuffing(MpegEncContext *s)
352
396
{
353
 
    int length, i;
 
397
    int i;
354
398
    PutBitContext *pbc = &s->pb;
355
399
    int mb_y = s->mb_y - !s->mb_x;
356
 
    length= (-put_bits_count(pbc))&7;
357
 
    if(length) put_bits(pbc, length, (1<<length)-1);
358
400
 
359
 
    flush_put_bits(&s->pb);
360
 
    escape_FF(s, s->esc_pos);
 
401
    ff_mjpeg_escape_FF(pbc, s->esc_pos);
361
402
 
362
403
    if((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height)
363
404
        put_marker(pbc, RST0 + (mb_y&7));
367
408
        s->last_dc[i] = 128 << s->intra_dc_precision;
368
409
}
369
410
 
370
 
void ff_mjpeg_encode_picture_trailer(MpegEncContext *s)
 
411
void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
371
412
{
372
 
 
373
 
    av_assert1((s->header_bits&7)==0);
374
 
 
375
 
 
376
 
    put_marker(&s->pb, EOI);
 
413
    av_assert1((header_bits & 7) == 0);
 
414
 
 
415
    put_marker(pb, EOI);
377
416
}
378
417
 
379
 
void ff_mjpeg_encode_dc(MpegEncContext *s, int val,
 
418
void ff_mjpeg_encode_dc(PutBitContext *pb, int val,
380
419
                        uint8_t *huff_size, uint16_t *huff_code)
381
420
{
382
421
    int mant, nbits;
383
422
 
384
423
    if (val == 0) {
385
 
        put_bits(&s->pb, huff_size[0], huff_code[0]);
 
424
        put_bits(pb, huff_size[0], huff_code[0]);
386
425
    } else {
387
426
        mant = val;
388
427
        if (val < 0) {
392
431
 
393
432
        nbits= av_log2_16bit(val) + 1;
394
433
 
395
 
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 
434
        put_bits(pb, huff_size[nbits], huff_code[nbits]);
396
435
 
397
 
        put_sbits(&s->pb, nbits, mant);
 
436
        put_sbits(pb, nbits, mant);
398
437
    }
399
438
}
400
439
 
411
450
    dc = block[0]; /* overflow is impossible */
412
451
    val = dc - s->last_dc[component];
413
452
    if (n < 4) {
414
 
        ff_mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 
453
        ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
415
454
        huff_size_ac = m->huff_size_ac_luminance;
416
455
        huff_code_ac = m->huff_code_ac_luminance;
417
456
    } else {
418
 
        ff_mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 
457
        ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
419
458
        huff_size_ac = m->huff_size_ac_chrominance;
420
459
        huff_code_ac = m->huff_code_ac_chrominance;
421
460
    }
441
480
                mant--;
442
481
            }
443
482
 
444
 
            nbits= av_log2(val) + 1;
 
483
            nbits= av_log2_16bit(val) + 1;
445
484
            code = (run << 4) | nbits;
446
485
 
447
486
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
498
537
 
499
538
{
500
539
    MpegEncContext *s = avctx->priv_data;
501
 
    AVFrame pic = *pic_arg;
502
 
    int i;
 
540
    AVFrame *pic;
 
541
    int i, ret;
 
542
    int chroma_h_shift, chroma_v_shift;
 
543
 
 
544
    av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
503
545
 
504
546
    //CODEC_FLAG_EMU_EDGE have to be cleared
505
547
    if(s->avctx->flags & CODEC_FLAG_EMU_EDGE)
506
 
        return -1;
 
548
        return AVERROR(EINVAL);
507
549
 
 
550
    pic = av_frame_alloc();
 
551
    if (!pic)
 
552
        return AVERROR(ENOMEM);
 
553
    av_frame_ref(pic, pic_arg);
508
554
    //picture should be flipped upside-down
509
555
    for(i=0; i < 3; i++) {
510
 
        pic.data[i] += (pic.linesize[i] * (s->mjpeg_vsample[i] * (8 * s->mb_height -((s->height/V_MAX)&7)) - 1 ));
511
 
        pic.linesize[i] *= -1;
 
556
        int vsample = i ? 2 >> chroma_v_shift : 2;
 
557
        pic->data[i] += (pic->linesize[i] * (vsample * (8 * s->mb_height -((s->height/V_MAX)&7)) - 1 ));
 
558
        pic->linesize[i] *= -1;
512
559
    }
513
 
    return ff_MPV_encode_picture(avctx, pkt, &pic, got_packet);
 
560
    ret = ff_MPV_encode_picture(avctx, pkt, pic, got_packet);
 
561
    av_frame_free(&pic);
 
562
    return ret;
514
563
}
515
564
 
516
565
#if CONFIG_MJPEG_ENCODER