FFmpeg
cinepakenc.c
Go to the documentation of this file.
1 /*
2  * Cinepak encoder (c) 2011 Tomas Härdin
3  * http://titan.codemill.se/~tomhar/cinepakenc.patch
4  *
5  * Fixes and improvements, vintage decoders compatibility
6  * (c) 2013, 2014 Rl, Aetey Global Technologies AB
7  *
8  * Permission is hereby granted, free of charge, to any person obtaining a
9  * copy of this software and associated documentation files (the "Software"),
10  * to deal in the Software without restriction, including without limitation
11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12  * and/or sell copies of the Software, and to permit persons to whom the
13  * Software is furnished to do so, subject to the following conditions:
14  *
15  * The above copyright notice and this permission notice shall be included
16  * in all copies or substantial portions of the Software.
17  *
18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
22  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24  * OTHER DEALINGS IN THE SOFTWARE.
25  */
26 
27 /*
28  * TODO:
29  * - optimize: color space conversion (move conversion to libswscale), ...
30  * MAYBE:
31  * - "optimally" split the frame into several non-regular areas
32  * using a separate codebook pair for each area and approximating
33  * the area by several rectangular strips (generally not full width ones)
34  * (use quadtree splitting? a simple fixed-granularity grid?)
35  */
36 
37 #include <string.h>
38 
39 #include "libavutil/avassert.h"
40 #include "libavutil/common.h"
41 #include "libavutil/internal.h"
42 #include "libavutil/intreadwrite.h"
43 #include "libavutil/lfg.h"
44 #include "libavutil/opt.h"
45 
46 #include "avcodec.h"
47 #include "elbg.h"
48 #include "internal.h"
49 
50 #define CVID_HEADER_SIZE 10
51 #define STRIP_HEADER_SIZE 12
52 #define CHUNK_HEADER_SIZE 4
53 
54 #define MB_SIZE 4 //4x4 MBs
55 #define MB_AREA (MB_SIZE * MB_SIZE)
56 
57 #define VECTOR_MAX 6 // six or four entries per vector depending on format
58 #define CODEBOOK_MAX 256 // size of a codebook
59 
60 #define MAX_STRIPS 32 // Note: having fewer choices regarding the number of strips speeds up encoding (obviously)
61 #define MIN_STRIPS 1 // Note: having more strips speeds up encoding the frame (this is less obvious)
62 // MAX_STRIPS limits the maximum quality you can reach
63 // when you want high quality on high resolutions,
64 // MIN_STRIPS limits the minimum efficiently encodable bit rate
65 // on low resolutions
66 // the numbers are only used for brute force optimization for the first frame,
67 // for the following frames they are adaptively readjusted
68 // NOTE the decoder in ffmpeg has its own arbitrary limitation on the number
69 // of strips, currently 32
70 
71 typedef enum CinepakMode {
75 
77 } CinepakMode;
78 
79 typedef enum mb_encoding {
83 
85 } mb_encoding;
86 
87 typedef struct mb_info {
88  int v1_vector; // index into v1 codebook
89  int v1_error; // error when using V1 encoding
90  int v4_vector[4]; // indices into v4 codebook
91  int v4_error; // error when using V4 encoding
92  int skip_error; // error when block is skipped (aka copied from last frame)
93  mb_encoding best_encoding; // last result from calculate_mode_score()
94 } mb_info;
95 
96 typedef struct strip_info {
97  int v1_codebook[CODEBOOK_MAX * VECTOR_MAX];
98  int v4_codebook[CODEBOOK_MAX * VECTOR_MAX];
99  int v1_size;
100  int v4_size;
102 } strip_info;
103 
104 typedef struct CinepakEncContext {
105  const AVClass *class;
107  unsigned char *pict_bufs[4], *strip_buf, *frame_buf;
113  int w, h;
115  int curframe, keyint;
117  uint64_t lambda;
120  mb_info *mb; // MB RD state
121  int min_strips; // the current limit
122  int max_strips; // the current limit
123  // options
130 
131 #define OFFSET(x) offsetof(CinepakEncContext, x)
132 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
133 static const AVOption options[] = {
134  { "max_extra_cb_iterations", "Max extra codebook recalculation passes, more is better and slower",
135  OFFSET(max_extra_cb_iterations), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, INT_MAX, VE },
136  { "skip_empty_cb", "Avoid wasting bytes, ignore vintage MacOS decoder",
137  OFFSET(skip_empty_cb), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
138  { "max_strips", "Limit strips/frame, vintage compatible is 1..3, otherwise the more the better",
139  OFFSET(max_max_strips), AV_OPT_TYPE_INT, { .i64 = 3 }, MIN_STRIPS, MAX_STRIPS, VE },
140  { "min_strips", "Enforce min strips/frame, more is worse and faster, must be <= max_strips",
141  OFFSET(min_min_strips), AV_OPT_TYPE_INT, { .i64 = MIN_STRIPS }, MIN_STRIPS, MAX_STRIPS, VE },
142  { "strip_number_adaptivity", "How fast the strip number adapts, more is slightly better, much slower",
143  OFFSET(strip_number_delta_range), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, MAX_STRIPS - MIN_STRIPS, VE },
144  { NULL },
145 };
146 
147 static const AVClass cinepak_class = {
148  .class_name = "cinepak",
149  .item_name = av_default_item_name,
150  .option = options,
151  .version = LIBAVUTIL_VERSION_INT,
152 };
153 
155 {
156  CinepakEncContext *s = avctx->priv_data;
157  int x, mb_count, strip_buf_size, frame_buf_size;
158 
159  if (avctx->width & 3 || avctx->height & 3) {
160  av_log(avctx, AV_LOG_ERROR, "width and height must be multiples of four (got %ix%i)\n",
161  avctx->width, avctx->height);
162  return AVERROR(EINVAL);
163  }
164 
165  if (s->min_min_strips > s->max_max_strips) {
166  av_log(avctx, AV_LOG_ERROR, "minimum number of strips must not exceed maximum (got %i and %i)\n",
168  return AVERROR(EINVAL);
169  }
170 
171  if (!(s->last_frame = av_frame_alloc()))
172  return AVERROR(ENOMEM);
173  if (!(s->best_frame = av_frame_alloc()))
174  return AVERROR(ENOMEM);
175  if (!(s->scratch_frame = av_frame_alloc()))
176  return AVERROR(ENOMEM);
177  if (avctx->pix_fmt == AV_PIX_FMT_RGB24)
178  if (!(s->input_frame = av_frame_alloc()))
179  return AVERROR(ENOMEM);
180 
181  if (!(s->codebook_input = av_malloc_array((avctx->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4) * (avctx->width * avctx->height) >> 2, sizeof(*s->codebook_input))))
182  return AVERROR(ENOMEM);
183 
184  if (!(s->codebook_closest = av_malloc_array((avctx->width * avctx->height) >> 2, sizeof(*s->codebook_closest))))
185  return AVERROR(ENOMEM);;
186 
187  for (x = 0; x < (avctx->pix_fmt == AV_PIX_FMT_RGB24 ? 4 : 3); x++)
188  if (!(s->pict_bufs[x] = av_malloc((avctx->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4) * (avctx->width * avctx->height) >> 2)))
189  return AVERROR(ENOMEM);
190 
191  mb_count = avctx->width * avctx->height / MB_AREA;
192 
193  // the largest possible chunk is 0x31 with all MBs encoded in V4 mode
194  // and full codebooks being replaced in INTER mode,
195  // which is 34 bits per MB
196  // and 2*256 extra flag bits per strip
197  strip_buf_size = STRIP_HEADER_SIZE + 3 * CHUNK_HEADER_SIZE + 2 * VECTOR_MAX * CODEBOOK_MAX + 4 * (mb_count + (mb_count + 15) / 16) + (2 * CODEBOOK_MAX) / 8;
198 
199  frame_buf_size = CVID_HEADER_SIZE + s->max_max_strips * strip_buf_size;
200 
201  if (!(s->strip_buf = av_malloc(strip_buf_size)))
202  return AVERROR(ENOMEM);
203 
204  if (!(s->frame_buf = av_malloc(frame_buf_size)))
205  return AVERROR(ENOMEM);
206 
207  if (!(s->mb = av_malloc_array(mb_count, sizeof(mb_info))))
208  return AVERROR(ENOMEM);
209 
210  av_lfg_init(&s->randctx, 1);
211  s->avctx = avctx;
212  s->w = avctx->width;
213  s->h = avctx->height;
214  s->frame_buf_size = frame_buf_size;
215  s->curframe = 0;
216  s->keyint = avctx->keyint_min;
217  s->pix_fmt = avctx->pix_fmt;
218 
219  // set up AVFrames
220  s->last_frame->data[0] = s->pict_bufs[0];
221  s->last_frame->linesize[0] = s->w;
222  s->best_frame->data[0] = s->pict_bufs[1];
223  s->best_frame->linesize[0] = s->w;
224  s->scratch_frame->data[0] = s->pict_bufs[2];
225  s->scratch_frame->linesize[0] = s->w;
226 
227  if (s->pix_fmt == AV_PIX_FMT_RGB24) {
228  s->last_frame->data[1] = s->last_frame->data[0] + s->w * s->h;
229  s->last_frame->data[2] = s->last_frame->data[1] + ((s->w * s->h) >> 2);
230  s->last_frame->linesize[1] =
231  s->last_frame->linesize[2] = s->w >> 1;
232 
233  s->best_frame->data[1] = s->best_frame->data[0] + s->w * s->h;
234  s->best_frame->data[2] = s->best_frame->data[1] + ((s->w * s->h) >> 2);
235  s->best_frame->linesize[1] =
236  s->best_frame->linesize[2] = s->w >> 1;
237 
238  s->scratch_frame->data[1] = s->scratch_frame->data[0] + s->w * s->h;
239  s->scratch_frame->data[2] = s->scratch_frame->data[1] + ((s->w * s->h) >> 2);
240  s->scratch_frame->linesize[1] =
241  s->scratch_frame->linesize[2] = s->w >> 1;
242 
243  s->input_frame->data[0] = s->pict_bufs[3];
244  s->input_frame->linesize[0] = s->w;
245  s->input_frame->data[1] = s->input_frame->data[0] + s->w * s->h;
246  s->input_frame->data[2] = s->input_frame->data[1] + ((s->w * s->h) >> 2);
247  s->input_frame->linesize[1] =
248  s->input_frame->linesize[2] = s->w >> 1;
249  }
250 
251  s->min_strips = s->min_min_strips;
252  s->max_strips = s->max_max_strips;
253 
254  return 0;
255 }
256 
258  strip_info *info, int report,
259  int *training_set_v1_shrunk,
260  int *training_set_v4_shrunk)
261 {
262  // score = FF_LAMBDA_SCALE * error + lambda * bits
263  int x;
264  int entry_size = s->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4;
265  int mb_count = s->w * h / MB_AREA;
266  mb_info *mb;
267  int64_t score1, score2, score3;
268  int64_t ret = s->lambda * ((info->v1_size ? CHUNK_HEADER_SIZE + info->v1_size * entry_size : 0) +
269  (info->v4_size ? CHUNK_HEADER_SIZE + info->v4_size * entry_size : 0) +
270  CHUNK_HEADER_SIZE) << 3;
271 
272  switch (info->mode) {
273  case MODE_V1_ONLY:
274  // one byte per MB
275  ret += s->lambda * 8 * mb_count;
276 
277  // while calculating we assume all blocks are ENC_V1
278  for (x = 0; x < mb_count; x++) {
279  mb = &s->mb[x];
280  ret += FF_LAMBDA_SCALE * mb->v1_error;
281  // this function is never called for report in MODE_V1_ONLY
282  // if (!report)
283  mb->best_encoding = ENC_V1;
284  }
285 
286  break;
287  case MODE_V1_V4:
288  // 9 or 33 bits per MB
289  if (report) {
290  // no moves between the corresponding training sets are allowed
291  *training_set_v1_shrunk = *training_set_v4_shrunk = 0;
292  for (x = 0; x < mb_count; x++) {
293  int mberr;
294  mb = &s->mb[x];
295  if (mb->best_encoding == ENC_V1)
296  score1 = s->lambda * 9 + FF_LAMBDA_SCALE * (mberr = mb->v1_error);
297  else
298  score1 = s->lambda * 33 + FF_LAMBDA_SCALE * (mberr = mb->v4_error);
299  ret += score1;
300  }
301  } else { // find best mode per block
302  for (x = 0; x < mb_count; x++) {
303  mb = &s->mb[x];
304  score1 = s->lambda * 9 + FF_LAMBDA_SCALE * mb->v1_error;
305  score2 = s->lambda * 33 + FF_LAMBDA_SCALE * mb->v4_error;
306 
307  if (score1 <= score2) {
308  ret += score1;
309  mb->best_encoding = ENC_V1;
310  } else {
311  ret += score2;
312  mb->best_encoding = ENC_V4;
313  }
314  }
315  }
316 
317  break;
318  case MODE_MC:
319  // 1, 10 or 34 bits per MB
320  if (report) {
321  int v1_shrunk = 0, v4_shrunk = 0;
322  for (x = 0; x < mb_count; x++) {
323  mb = &s->mb[x];
324  // it is OK to move blocks to ENC_SKIP here
325  // but not to any codebook encoding!
326  score1 = s->lambda * 1 + FF_LAMBDA_SCALE * mb->skip_error;
327  if (mb->best_encoding == ENC_SKIP) {
328  ret += score1;
329  } else if (mb->best_encoding == ENC_V1) {
330  if ((score2 = s->lambda * 10 + FF_LAMBDA_SCALE * mb->v1_error) >= score1) {
331  mb->best_encoding = ENC_SKIP;
332  ++v1_shrunk;
333  ret += score1;
334  } else {
335  ret += score2;
336  }
337  } else {
338  if ((score3 = s->lambda * 34 + FF_LAMBDA_SCALE * mb->v4_error) >= score1) {
339  mb->best_encoding = ENC_SKIP;
340  ++v4_shrunk;
341  ret += score1;
342  } else {
343  ret += score3;
344  }
345  }
346  }
347  *training_set_v1_shrunk = v1_shrunk;
348  *training_set_v4_shrunk = v4_shrunk;
349  } else { // find best mode per block
350  for (x = 0; x < mb_count; x++) {
351  mb = &s->mb[x];
352  score1 = s->lambda * 1 + FF_LAMBDA_SCALE * mb->skip_error;
353  score2 = s->lambda * 10 + FF_LAMBDA_SCALE * mb->v1_error;
354  score3 = s->lambda * 34 + FF_LAMBDA_SCALE * mb->v4_error;
355 
356  if (score1 <= score2 && score1 <= score3) {
357  ret += score1;
358  mb->best_encoding = ENC_SKIP;
359  } else if (score2 <= score3) {
360  ret += score2;
361  mb->best_encoding = ENC_V1;
362  } else {
363  ret += score3;
364  mb->best_encoding = ENC_V4;
365  }
366  }
367  }
368 
369  break;
370  }
371 
372  return ret;
373 }
374 
375 static int write_chunk_header(unsigned char *buf, int chunk_type, int chunk_size)
376 {
377  buf[0] = chunk_type;
378  AV_WB24(&buf[1], chunk_size + CHUNK_HEADER_SIZE);
379  return CHUNK_HEADER_SIZE;
380 }
381 
383  int chunk_type_yuv, int chunk_type_gray,
384  unsigned char *buf)
385 {
386  int x, y, ret, entry_size = s->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4;
387  int incremental_codebook_replacement_mode = 0; // hardcoded here,
388  // the compiler should notice that this is a constant -- rl
389 
390  ret = write_chunk_header(buf,
391  s->pix_fmt == AV_PIX_FMT_RGB24 ?
392  chunk_type_yuv + (incremental_codebook_replacement_mode ? 1 : 0) :
393  chunk_type_gray + (incremental_codebook_replacement_mode ? 1 : 0),
394  entry_size * size +
395  (incremental_codebook_replacement_mode ? (size + 31) / 32 * 4 : 0));
396 
397  // we do codebook encoding according to the "intra" mode
398  // but we keep the "dead" code for reference in case we will want
399  // to use incremental codebook updates (which actually would give us
400  // "kind of" motion compensation, especially in 1 strip/frame case) -- rl
401  // (of course, the code will be not useful as-is)
402  if (incremental_codebook_replacement_mode) {
403  int flags = 0;
404  int flagsind;
405  for (x = 0; x < size; x++) {
406  if (flags == 0) {
407  flagsind = ret;
408  ret += 4;
409  flags = 0x80000000;
410  } else
411  flags = ((flags >> 1) | 0x80000000);
412  for (y = 0; y < entry_size; y++)
413  buf[ret++] = codebook[y + x * entry_size] ^ (y >= 4 ? 0x80 : 0);
414  if ((flags & 0xffffffff) == 0xffffffff) {
415  AV_WB32(&buf[flagsind], flags);
416  flags = 0;
417  }
418  }
419  if (flags)
420  AV_WB32(&buf[flagsind], flags);
421  } else
422  for (x = 0; x < size; x++)
423  for (y = 0; y < entry_size; y++)
424  buf[ret++] = codebook[y + x * entry_size] ^ (y >= 4 ? 0x80 : 0);
425 
426  return ret;
427 }
428 
429 // sets out to the sub picture starting at (x,y) in in
430 static void get_sub_picture(CinepakEncContext *s, int x, int y,
431  uint8_t * in_data[4], int in_linesize[4],
432  uint8_t *out_data[4], int out_linesize[4])
433 {
434  out_data[0] = in_data[0] + x + y * in_linesize[0];
435  out_linesize[0] = in_linesize[0];
436 
437  if (s->pix_fmt == AV_PIX_FMT_RGB24) {
438  out_data[1] = in_data[1] + (x >> 1) + (y >> 1) * in_linesize[1];
439  out_linesize[1] = in_linesize[1];
440 
441  out_data[2] = in_data[2] + (x >> 1) + (y >> 1) * in_linesize[2];
442  out_linesize[2] = in_linesize[2];
443  }
444 }
445 
446 // decodes the V1 vector in mb into the 4x4 MB pointed to by data
448  int linesize[4], int v1_vector, strip_info *info)
449 {
450  int entry_size = s->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4;
451 
452  data[0][0] =
453  data[0][1] =
454  data[0][ linesize[0]] =
455  data[0][1 + linesize[0]] = info->v1_codebook[v1_vector * entry_size];
456 
457  data[0][2] =
458  data[0][3] =
459  data[0][2 + linesize[0]] =
460  data[0][3 + linesize[0]] = info->v1_codebook[v1_vector * entry_size + 1];
461 
462  data[0][ 2 * linesize[0]] =
463  data[0][1 + 2 * linesize[0]] =
464  data[0][ 3 * linesize[0]] =
465  data[0][1 + 3 * linesize[0]] = info->v1_codebook[v1_vector * entry_size + 2];
466 
467  data[0][2 + 2 * linesize[0]] =
468  data[0][3 + 2 * linesize[0]] =
469  data[0][2 + 3 * linesize[0]] =
470  data[0][3 + 3 * linesize[0]] = info->v1_codebook[v1_vector * entry_size + 3];
471 
472  if (s->pix_fmt == AV_PIX_FMT_RGB24) {
473  data[1][0] =
474  data[1][1] =
475  data[1][ linesize[1]] =
476  data[1][1 + linesize[1]] = info->v1_codebook[v1_vector * entry_size + 4];
477 
478  data[2][0] =
479  data[2][1] =
480  data[2][ linesize[2]] =
481  data[2][1 + linesize[2]] = info->v1_codebook[v1_vector * entry_size + 5];
482  }
483 }
484 
485 // decodes the V4 vectors in mb into the 4x4 MB pointed to by data
487  int linesize[4], int *v4_vector, strip_info *info)
488 {
489  int i, x, y, entry_size = s->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4;
490 
491  for (i = y = 0; y < 4; y += 2) {
492  for (x = 0; x < 4; x += 2, i++) {
493  data[0][x + y * linesize[0]] = info->v4_codebook[v4_vector[i] * entry_size];
494  data[0][x + 1 + y * linesize[0]] = info->v4_codebook[v4_vector[i] * entry_size + 1];
495  data[0][x + (y + 1) * linesize[0]] = info->v4_codebook[v4_vector[i] * entry_size + 2];
496  data[0][x + 1 + (y + 1) * linesize[0]] = info->v4_codebook[v4_vector[i] * entry_size + 3];
497 
498  if (s->pix_fmt == AV_PIX_FMT_RGB24) {
499  data[1][(x >> 1) + (y >> 1) * linesize[1]] = info->v4_codebook[v4_vector[i] * entry_size + 4];
500  data[2][(x >> 1) + (y >> 1) * linesize[2]] = info->v4_codebook[v4_vector[i] * entry_size + 5];
501  }
502  }
503  }
504 }
505 
507  uint8_t *a_data[4], int a_linesize[4],
508  uint8_t *b_data[4], int b_linesize[4])
509 {
510  int y, p;
511 
512  for (y = 0; y < MB_SIZE; y++)
513  memcpy(a_data[0] + y * a_linesize[0], b_data[0] + y * b_linesize[0],
514  MB_SIZE);
515 
516  if (s->pix_fmt == AV_PIX_FMT_RGB24) {
517  for (p = 1; p <= 2; p++)
518  for (y = 0; y < MB_SIZE / 2; y++)
519  memcpy(a_data[p] + y * a_linesize[p],
520  b_data[p] + y * b_linesize[p],
521  MB_SIZE / 2);
522  }
523 }
524 
525 static int encode_mode(CinepakEncContext *s, int h,
526  uint8_t *scratch_data[4], int scratch_linesize[4],
527  uint8_t *last_data[4], int last_linesize[4],
528  strip_info *info, unsigned char *buf)
529 {
530  int x, y, z, bits, temp_size, header_ofs, ret = 0, mb_count = s->w * h / MB_AREA;
531  int needs_extra_bit, should_write_temp;
532  uint32_t flags;
533  unsigned char temp[64]; // 32/2 = 16 V4 blocks at 4 B each -> 64 B
534  mb_info *mb;
535  uint8_t *sub_scratch_data[4] = { 0 }, *sub_last_data[4] = { 0 };
536  int sub_scratch_linesize[4] = { 0 }, sub_last_linesize[4] = { 0 };
537 
538  // encode codebooks
539  ////// MacOS vintage decoder compatibility dictates the presence of
540  ////// the codebook chunk even when the codebook is empty - pretty dumb...
541  ////// and also the certain order of the codebook chunks -- rl
542  if (info->v4_size || !s->skip_empty_cb)
543  ret += encode_codebook(s, info->v4_codebook, info->v4_size, 0x20, 0x24, buf + ret);
544 
545  if (info->v1_size || !s->skip_empty_cb)
546  ret += encode_codebook(s, info->v1_codebook, info->v1_size, 0x22, 0x26, buf + ret);
547 
548  // update scratch picture
549  for (z = y = 0; y < h; y += MB_SIZE)
550  for (x = 0; x < s->w; x += MB_SIZE, z++) {
551  mb = &s->mb[z];
552 
553  get_sub_picture(s, x, y, scratch_data, scratch_linesize,
554  sub_scratch_data, sub_scratch_linesize);
555 
556  if (info->mode == MODE_MC && mb->best_encoding == ENC_SKIP) {
557  get_sub_picture(s, x, y, last_data, last_linesize,
558  sub_last_data, sub_last_linesize);
559  copy_mb(s, sub_scratch_data, sub_scratch_linesize,
560  sub_last_data, sub_last_linesize);
561  } else if (info->mode == MODE_V1_ONLY || mb->best_encoding == ENC_V1)
562  decode_v1_vector(s, sub_scratch_data, sub_scratch_linesize,
563  mb->v1_vector, info);
564  else
565  decode_v4_vector(s, sub_scratch_data, sub_scratch_linesize,
566  mb->v4_vector, info);
567  }
568 
569  switch (info->mode) {
570  case MODE_V1_ONLY:
571  ret += write_chunk_header(buf + ret, 0x32, mb_count);
572 
573  for (x = 0; x < mb_count; x++)
574  buf[ret++] = s->mb[x].v1_vector;
575 
576  break;
577  case MODE_V1_V4:
578  // remember header position
579  header_ofs = ret;
580  ret += CHUNK_HEADER_SIZE;
581 
582  for (x = 0; x < mb_count; x += 32) {
583  flags = 0;
584  for (y = x; y < FFMIN(x + 32, mb_count); y++)
585  if (s->mb[y].best_encoding == ENC_V4)
586  flags |= 1U << (31 - y + x);
587 
588  AV_WB32(&buf[ret], flags);
589  ret += 4;
590 
591  for (y = x; y < FFMIN(x + 32, mb_count); y++) {
592  mb = &s->mb[y];
593 
594  if (mb->best_encoding == ENC_V1)
595  buf[ret++] = mb->v1_vector;
596  else
597  for (z = 0; z < 4; z++)
598  buf[ret++] = mb->v4_vector[z];
599  }
600  }
601 
602  write_chunk_header(buf + header_ofs, 0x30, ret - header_ofs - CHUNK_HEADER_SIZE);
603 
604  break;
605  case MODE_MC:
606  // remember header position
607  header_ofs = ret;
608  ret += CHUNK_HEADER_SIZE;
609  flags = bits = temp_size = 0;
610 
611  for (x = 0; x < mb_count; x++) {
612  mb = &s->mb[x];
613  flags |= (uint32_t)(mb->best_encoding != ENC_SKIP) << (31 - bits++);
614  needs_extra_bit = 0;
615  should_write_temp = 0;
616 
617  if (mb->best_encoding != ENC_SKIP) {
618  if (bits < 32)
619  flags |= (uint32_t)(mb->best_encoding == ENC_V4) << (31 - bits++);
620  else
621  needs_extra_bit = 1;
622  }
623 
624  if (bits == 32) {
625  AV_WB32(&buf[ret], flags);
626  ret += 4;
627  flags = bits = 0;
628 
629  if (mb->best_encoding == ENC_SKIP || needs_extra_bit) {
630  memcpy(&buf[ret], temp, temp_size);
631  ret += temp_size;
632  temp_size = 0;
633  } else
634  should_write_temp = 1;
635  }
636 
637  if (needs_extra_bit) {
638  flags = (uint32_t)(mb->best_encoding == ENC_V4) << 31;
639  bits = 1;
640  }
641 
642  if (mb->best_encoding == ENC_V1)
643  temp[temp_size++] = mb->v1_vector;
644  else if (mb->best_encoding == ENC_V4)
645  for (z = 0; z < 4; z++)
646  temp[temp_size++] = mb->v4_vector[z];
647 
648  if (should_write_temp) {
649  memcpy(&buf[ret], temp, temp_size);
650  ret += temp_size;
651  temp_size = 0;
652  }
653  }
654 
655  if (bits > 0) {
656  AV_WB32(&buf[ret], flags);
657  ret += 4;
658  memcpy(&buf[ret], temp, temp_size);
659  ret += temp_size;
660  }
661 
662  write_chunk_header(buf + header_ofs, 0x31, ret - header_ofs - CHUNK_HEADER_SIZE);
663 
664  break;
665  }
666 
667  return ret;
668 }
669 
670 // computes distortion of 4x4 MB in b compared to a
672  uint8_t *a_data[4], int a_linesize[4],
673  uint8_t *b_data[4], int b_linesize[4])
674 {
675  int x, y, p, d, ret = 0;
676 
677  for (y = 0; y < MB_SIZE; y++)
678  for (x = 0; x < MB_SIZE; x++) {
679  d = a_data[0][x + y * a_linesize[0]] - b_data[0][x + y * b_linesize[0]];
680  ret += d * d;
681  }
682 
683  if (s->pix_fmt == AV_PIX_FMT_RGB24) {
684  for (p = 1; p <= 2; p++) {
685  for (y = 0; y < MB_SIZE / 2; y++)
686  for (x = 0; x < MB_SIZE / 2; x++) {
687  d = a_data[p][x + y * a_linesize[p]] - b_data[p][x + y * b_linesize[p]];
688  ret += d * d;
689  }
690  }
691  }
692 
693  return ret;
694 }
695 
696 // return the possibly adjusted size of the codebook
697 #define CERTAIN(x) ((x) != ENC_UNCERTAIN)
698 static int quantize(CinepakEncContext *s, int h, uint8_t *data[4],
699  int linesize[4], int v1mode, strip_info *info,
700  mb_encoding encoding)
701 {
702  int x, y, i, j, k, x2, y2, x3, y3, plane, shift, mbn;
703  int entry_size = s->pix_fmt == AV_PIX_FMT_RGB24 ? 6 : 4;
704  int *codebook = v1mode ? info->v1_codebook : info->v4_codebook;
705  int size = v1mode ? info->v1_size : info->v4_size;
706  int64_t total_error = 0;
707  uint8_t vq_pict_buf[(MB_AREA * 3) / 2];
708  uint8_t *sub_data[4], *vq_data[4];
709  int sub_linesize[4], vq_linesize[4];
710 
711  for (mbn = i = y = 0; y < h; y += MB_SIZE) {
712  for (x = 0; x < s->w; x += MB_SIZE, ++mbn) {
713  int *base;
714 
715  if (CERTAIN(encoding)) {
716  // use for the training only the blocks known to be to be encoded [sic:-]
717  if (s->mb[mbn].best_encoding != encoding)
718  continue;
719  }
720 
721  base = s->codebook_input + i * entry_size;
722  if (v1mode) {
723  // subsample
724  for (j = y2 = 0; y2 < entry_size; y2 += 2)
725  for (x2 = 0; x2 < 4; x2 += 2, j++) {
726  plane = y2 < 4 ? 0 : 1 + (x2 >> 1);
727  shift = y2 < 4 ? 0 : 1;
728  x3 = shift ? 0 : x2;
729  y3 = shift ? 0 : y2;
730  base[j] = (data[plane][((x + x3) >> shift) + ((y + y3) >> shift) * linesize[plane]] +
731  data[plane][((x + x3) >> shift) + 1 + ((y + y3) >> shift) * linesize[plane]] +
732  data[plane][((x + x3) >> shift) + (((y + y3) >> shift) + 1) * linesize[plane]] +
733  data[plane][((x + x3) >> shift) + 1 + (((y + y3) >> shift) + 1) * linesize[plane]]) >> 2;
734  }
735  } else {
736  // copy
737  for (j = y2 = 0; y2 < MB_SIZE; y2 += 2) {
738  for (x2 = 0; x2 < MB_SIZE; x2 += 2)
739  for (k = 0; k < entry_size; k++, j++) {
740  plane = k >= 4 ? k - 3 : 0;
741 
742  if (k >= 4) {
743  x3 = (x + x2) >> 1;
744  y3 = (y + y2) >> 1;
745  } else {
746  x3 = x + x2 + (k & 1);
747  y3 = y + y2 + (k >> 1);
748  }
749 
750  base[j] = data[plane][x3 + y3 * linesize[plane]];
751  }
752  }
753  }
754  i += v1mode ? 1 : 4;
755  }
756  }
757 
758  if (i == 0) // empty training set, nothing to do
759  return 0;
760  if (i < size)
761  size = i;
762 
763  avpriv_init_elbg(s->codebook_input, entry_size, i, codebook, size, 1, s->codebook_closest, &s->randctx);
764  avpriv_do_elbg(s->codebook_input, entry_size, i, codebook, size, 1, s->codebook_closest, &s->randctx);
765 
766  // set up vq_data, which contains a single MB
767  vq_data[0] = vq_pict_buf;
768  vq_linesize[0] = MB_SIZE;
769  vq_data[1] = &vq_pict_buf[MB_AREA];
770  vq_data[2] = vq_data[1] + (MB_AREA >> 2);
771  vq_linesize[1] =
772  vq_linesize[2] = MB_SIZE >> 1;
773 
774  // copy indices
775  for (i = j = y = 0; y < h; y += MB_SIZE)
776  for (x = 0; x < s->w; x += MB_SIZE, j++) {
777  mb_info *mb = &s->mb[j];
778  // skip uninteresting blocks if we know their preferred encoding
779  if (CERTAIN(encoding) && mb->best_encoding != encoding)
780  continue;
781 
782  // point sub_data to current MB
783  get_sub_picture(s, x, y, data, linesize, sub_data, sub_linesize);
784 
785  if (v1mode) {
786  mb->v1_vector = s->codebook_closest[i];
787 
788  // fill in vq_data with V1 data
789  decode_v1_vector(s, vq_data, vq_linesize, mb->v1_vector, info);
790 
791  mb->v1_error = compute_mb_distortion(s, sub_data, sub_linesize,
792  vq_data, vq_linesize);
793  total_error += mb->v1_error;
794  } else {
795  for (k = 0; k < 4; k++)
796  mb->v4_vector[k] = s->codebook_closest[i + k];
797 
798  // fill in vq_data with V4 data
799  decode_v4_vector(s, vq_data, vq_linesize, mb->v4_vector, info);
800 
801  mb->v4_error = compute_mb_distortion(s, sub_data, sub_linesize,
802  vq_data, vq_linesize);
803  total_error += mb->v4_error;
804  }
805  i += v1mode ? 1 : 4;
806  }
807  // check that we did it right in the beginning of the function
808  av_assert0(i >= size); // training set is no smaller than the codebook
809 
810  return size;
811 }
812 
814  uint8_t *last_data[4], int last_linesize[4],
815  uint8_t *data[4], int linesize[4],
816  strip_info *info)
817 {
818  int x, y, i;
819  uint8_t *sub_last_data [4], *sub_pict_data [4];
820  int sub_last_linesize[4], sub_pict_linesize[4];
821 
822  for (i = y = 0; y < h; y += MB_SIZE)
823  for (x = 0; x < s->w; x += MB_SIZE, i++) {
824  get_sub_picture(s, x, y, last_data, last_linesize,
825  sub_last_data, sub_last_linesize);
826  get_sub_picture(s, x, y, data, linesize,
827  sub_pict_data, sub_pict_linesize);
828 
829  s->mb[i].skip_error =
831  sub_last_data, sub_last_linesize,
832  sub_pict_data, sub_pict_linesize);
833  }
834 }
835 
836 static void write_strip_header(CinepakEncContext *s, int y, int h, int keyframe,
837  unsigned char *buf, int strip_size)
838 {
839  // actually we are exclusively using intra strip coding (how much can we win
840  // otherwise? how to choose which part of a codebook to update?),
841  // keyframes are different only because we disallow ENC_SKIP on them -- rl
842  // (besides, the logic here used to be inverted: )
843  // buf[0] = keyframe ? 0x11: 0x10;
844  buf[0] = keyframe ? 0x10 : 0x11;
845  AV_WB24(&buf[1], strip_size + STRIP_HEADER_SIZE);
846  // AV_WB16(&buf[4], y); /* using absolute y values works -- rl */
847  AV_WB16(&buf[4], 0); /* using relative values works as well -- rl */
848  AV_WB16(&buf[6], 0);
849  // AV_WB16(&buf[8], y + h); /* using absolute y values works -- rl */
850  AV_WB16(&buf[8], h); /* using relative values works as well -- rl */
851  AV_WB16(&buf[10], s->w);
852 }
853 
854 static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe,
855  uint8_t *last_data[4], int last_linesize[4],
856  uint8_t *data[4], int linesize[4],
857  uint8_t *scratch_data[4], int scratch_linesize[4],
858  unsigned char *buf, int64_t *best_score)
859 {
860  int64_t score = 0;
861  int best_size = 0;
863  // for codebook optimization:
864  int v1enough, v1_size, v4enough, v4_size;
865  int new_v1_size, new_v4_size;
866  int v1shrunk, v4shrunk;
867 
868  if (!keyframe)
869  calculate_skip_errors(s, h, last_data, last_linesize, data, linesize,
870  &info);
871 
872  // try some powers of 4 for the size of the codebooks
873  // constraint the v4 codebook to be no bigger than v1 one,
874  // (and no less than v1_size/4)
875  // thus making v1 preferable and possibly losing small details? should be ok
876 #define SMALLEST_CODEBOOK 1
877  for (v1enough = 0, v1_size = SMALLEST_CODEBOOK; v1_size <= CODEBOOK_MAX && !v1enough; v1_size <<= 2) {
878  for (v4enough = 0, v4_size = 0; v4_size <= v1_size && !v4enough; v4_size = v4_size ? v4_size << 2 : v1_size >= SMALLEST_CODEBOOK << 2 ? v1_size >> 2 : SMALLEST_CODEBOOK) {
880  // try all modes
881  for (mode = 0; mode < MODE_COUNT; mode++) {
882  // don't allow MODE_MC in intra frames
883  if (keyframe && mode == MODE_MC)
884  continue;
885 
886  if (mode == MODE_V1_ONLY) {
887  info.v1_size = v1_size;
888  // the size may shrink even before optimizations if the input is short:
889  info.v1_size = quantize(s, h, data, linesize, 1,
890  &info, ENC_UNCERTAIN);
891  if (info.v1_size < v1_size)
892  // too few eligible blocks, no sense in trying bigger sizes
893  v1enough = 1;
894 
895  info.v4_size = 0;
896  } else { // mode != MODE_V1_ONLY
897  // if v4 codebook is empty then only allow V1-only mode
898  if (!v4_size)
899  continue;
900 
901  if (mode == MODE_V1_V4) {
902  info.v4_size = v4_size;
903  info.v4_size = quantize(s, h, data, linesize, 0,
904  &info, ENC_UNCERTAIN);
905  if (info.v4_size < v4_size)
906  // too few eligible blocks, no sense in trying bigger sizes
907  v4enough = 1;
908  }
909  }
910 
911  info.mode = mode;
912  // choose the best encoding per block, based on current experience
913  score = calculate_mode_score(s, h, &info, 0,
914  &v1shrunk, &v4shrunk);
915 
916  if (mode != MODE_V1_ONLY) {
917  int extra_iterations_limit = s->max_extra_cb_iterations;
918  // recompute the codebooks, omitting the extra blocks
919  // we assume we _may_ come here with more blocks to encode than before
920  info.v1_size = v1_size;
921  new_v1_size = quantize(s, h, data, linesize, 1, &info, ENC_V1);
922  if (new_v1_size < info.v1_size)
923  info.v1_size = new_v1_size;
924  // we assume we _may_ come here with more blocks to encode than before
925  info.v4_size = v4_size;
926  new_v4_size = quantize(s, h, data, linesize, 0, &info, ENC_V4);
927  if (new_v4_size < info.v4_size)
928  info.v4_size = new_v4_size;
929  // calculate the resulting score
930  // (do not move blocks to codebook encodings now, as some blocks may have
931  // got bigger errors despite a smaller training set - but we do not
932  // ever grow the training sets back)
933  for (;;) {
934  score = calculate_mode_score(s, h, &info, 1,
935  &v1shrunk, &v4shrunk);
936  // do we have a reason to reiterate? if so, have we reached the limit?
937  if ((!v1shrunk && !v4shrunk) || !extra_iterations_limit--)
938  break;
939  // recompute the codebooks, omitting the extra blocks
940  if (v1shrunk) {
941  info.v1_size = v1_size;
942  new_v1_size = quantize(s, h, data, linesize, 1, &info, ENC_V1);
943  if (new_v1_size < info.v1_size)
944  info.v1_size = new_v1_size;
945  }
946  if (v4shrunk) {
947  info.v4_size = v4_size;
948  new_v4_size = quantize(s, h, data, linesize, 0, &info, ENC_V4);
949  if (new_v4_size < info.v4_size)
950  info.v4_size = new_v4_size;
951  }
952  }
953  }
954 
955  if (best_size == 0 || score < *best_score) {
956  *best_score = score;
957  best_size = encode_mode(s, h,
958  scratch_data, scratch_linesize,
959  last_data, last_linesize, &info,
961 
962  write_strip_header(s, y, h, keyframe, s->strip_buf, best_size);
963  }
964  }
965  }
966  }
967 
968  best_size += STRIP_HEADER_SIZE;
969  memcpy(buf, s->strip_buf, best_size);
970 
971  return best_size;
972 }
973 
974 static int write_cvid_header(CinepakEncContext *s, unsigned char *buf,
975  int num_strips, int data_size, int isakeyframe)
976 {
977  buf[0] = isakeyframe ? 0 : 1;
978  AV_WB24(&buf[1], data_size + CVID_HEADER_SIZE);
979  AV_WB16(&buf[4], s->w);
980  AV_WB16(&buf[6], s->h);
981  AV_WB16(&buf[8], num_strips);
982 
983  return CVID_HEADER_SIZE;
984 }
985 
987  int isakeyframe, unsigned char *buf, int buf_size)
988 {
989  int num_strips, strip, i, y, nexty, size, temp_size, best_size;
990  uint8_t *last_data [4], *data [4], *scratch_data [4];
991  int last_linesize[4], linesize[4], scratch_linesize[4];
992  int64_t best_score = 0, score, score_temp;
993  int best_nstrips;
994 
995  if (s->pix_fmt == AV_PIX_FMT_RGB24) {
996  int x;
997  // build a copy of the given frame in the correct colorspace
998  for (y = 0; y < s->h; y += 2)
999  for (x = 0; x < s->w; x += 2) {
1000  uint8_t *ir[2];
1001  int32_t r, g, b, rr, gg, bb;
1002  ir[0] = frame->data[0] + x * 3 + y * frame->linesize[0];
1003  ir[1] = ir[0] + frame->linesize[0];
1004  get_sub_picture(s, x, y,
1006  scratch_data, scratch_linesize);
1007  r = g = b = 0;
1008  for (i = 0; i < 4; ++i) {
1009  int i1, i2;
1010  i1 = (i & 1);
1011  i2 = (i >= 2);
1012  rr = ir[i2][i1 * 3 + 0];
1013  gg = ir[i2][i1 * 3 + 1];
1014  bb = ir[i2][i1 * 3 + 2];
1015  r += rr;
1016  g += gg;
1017  b += bb;
1018  // using fixed point arithmetic for portable repeatability, scaling by 2^23
1019  // "Y"
1020  // rr = 0.2857 * rr + 0.5714 * gg + 0.1429 * bb;
1021  rr = (2396625 * rr + 4793251 * gg + 1198732 * bb) >> 23;
1022  if (rr < 0)
1023  rr = 0;
1024  else if (rr > 255)
1025  rr = 255;
1026  scratch_data[0][i1 + i2 * scratch_linesize[0]] = rr;
1027  }
1028  // let us scale down as late as possible
1029  // r /= 4; g /= 4; b /= 4;
1030  // "U"
1031  // rr = -0.1429 * r - 0.2857 * g + 0.4286 * b;
1032  rr = (-299683 * r - 599156 * g + 898839 * b) >> 23;
1033  if (rr < -128)
1034  rr = -128;
1035  else if (rr > 127)
1036  rr = 127;
1037  scratch_data[1][0] = rr + 128; // quantize needs unsigned
1038  // "V"
1039  // rr = 0.3571 * r - 0.2857 * g - 0.0714 * b;
1040  rr = (748893 * r - 599156 * g - 149737 * b) >> 23;
1041  if (rr < -128)
1042  rr = -128;
1043  else if (rr > 127)
1044  rr = 127;
1045  scratch_data[2][0] = rr + 128; // quantize needs unsigned
1046  }
1047  }
1048 
1049  // would be nice but quite certainly incompatible with vintage players:
1050  // support encoding zero strips (meaning skip the whole frame)
1051  for (num_strips = s->min_strips; num_strips <= s->max_strips && num_strips <= s->h / MB_SIZE; num_strips++) {
1052  score = 0;
1053  size = 0;
1054 
1055  for (y = 0, strip = 1; y < s->h; strip++, y = nexty) {
1056  int strip_height;
1057 
1058  nexty = strip * s->h / num_strips; // <= s->h
1059  // make nexty the next multiple of 4 if not already there
1060  if (nexty & 3)
1061  nexty += 4 - (nexty & 3);
1062 
1063  strip_height = nexty - y;
1064  if (strip_height <= 0) { // can this ever happen?
1065  av_log(s->avctx, AV_LOG_INFO, "skipping zero height strip %i of %i\n", strip, num_strips);
1066  continue;
1067  }
1068 
1069  if (s->pix_fmt == AV_PIX_FMT_RGB24)
1070  get_sub_picture(s, 0, y,
1072  data, linesize);
1073  else
1074  get_sub_picture(s, 0, y,
1075  (uint8_t **)frame->data, (int *)frame->linesize,
1076  data, linesize);
1077  get_sub_picture(s, 0, y,
1079  last_data, last_linesize);
1080  get_sub_picture(s, 0, y,
1082  scratch_data, scratch_linesize);
1083 
1084  if ((temp_size = rd_strip(s, y, strip_height, isakeyframe,
1085  last_data, last_linesize, data, linesize,
1086  scratch_data, scratch_linesize,
1087  s->frame_buf + size + CVID_HEADER_SIZE,
1088  &score_temp)) < 0)
1089  return temp_size;
1090 
1091  score += score_temp;
1092  size += temp_size;
1093  }
1094 
1095  if (best_score == 0 || score < best_score) {
1096  best_score = score;
1097  best_size = size + write_cvid_header(s, s->frame_buf, num_strips, size, isakeyframe);
1098 
1100  memcpy(buf, s->frame_buf, best_size);
1101  best_nstrips = num_strips;
1102  }
1103  // avoid trying too many strip numbers without a real reason
1104  // (this makes the processing of the very first frame faster)
1105  if (num_strips - best_nstrips > 4)
1106  break;
1107  }
1108 
1109  // let the number of strips slowly adapt to the changes in the contents,
1110  // compared to full bruteforcing every time this will occasionally lead
1111  // to some r/d performance loss but makes encoding up to several times faster
1112  if (!s->strip_number_delta_range) {
1113  if (best_nstrips == s->max_strips) { // let us try to step up
1114  s->max_strips = best_nstrips + 1;
1115  if (s->max_strips >= s->max_max_strips)
1116  s->max_strips = s->max_max_strips;
1117  } else { // try to step down
1118  s->max_strips = best_nstrips;
1119  }
1120  s->min_strips = s->max_strips - 1;
1121  if (s->min_strips < s->min_min_strips)
1122  s->min_strips = s->min_min_strips;
1123  } else {
1124  s->max_strips = best_nstrips + s->strip_number_delta_range;
1125  if (s->max_strips >= s->max_max_strips)
1126  s->max_strips = s->max_max_strips;
1127  s->min_strips = best_nstrips - s->strip_number_delta_range;
1128  if (s->min_strips < s->min_min_strips)
1129  s->min_strips = s->min_min_strips;
1130  }
1131 
1132  return best_size;
1133 }
1134 
1136  const AVFrame *frame, int *got_packet)
1137 {
1138  CinepakEncContext *s = avctx->priv_data;
1139  int ret;
1140 
1141  s->lambda = frame->quality ? frame->quality - 1 : 2 * FF_LAMBDA_SCALE;
1142 
1143  if ((ret = ff_alloc_packet2(avctx, pkt, s->frame_buf_size, 0)) < 0)
1144  return ret;
1145  ret = rd_frame(s, frame, (s->curframe == 0), pkt->data, s->frame_buf_size);
1146  pkt->size = ret;
1147  if (s->curframe == 0)
1148  pkt->flags |= AV_PKT_FLAG_KEY;
1149  *got_packet = 1;
1150 
1151  FFSWAP(AVFrame *, s->last_frame, s->best_frame);
1152 
1153  if (++s->curframe >= s->keyint)
1154  s->curframe = 0;
1155 
1156  return 0;
1157 }
1158 
1160 {
1161  CinepakEncContext *s = avctx->priv_data;
1162  int x;
1163 
1167  if (avctx->pix_fmt == AV_PIX_FMT_RGB24)
1169  av_freep(&s->codebook_input);
1171  av_freep(&s->strip_buf);
1172  av_freep(&s->frame_buf);
1173  av_freep(&s->mb);
1174 
1175  for (x = 0; x < (avctx->pix_fmt == AV_PIX_FMT_RGB24 ? 4 : 3); x++)
1176  av_freep(&s->pict_bufs[x]);
1177 
1178  return 0;
1179 }
1180 
1182  .name = "cinepak",
1183  .long_name = NULL_IF_CONFIG_SMALL("Cinepak"),
1184  .type = AVMEDIA_TYPE_VIDEO,
1185  .id = AV_CODEC_ID_CINEPAK,
1186  .priv_data_size = sizeof(CinepakEncContext),
1188  .encode2 = cinepak_encode_frame,
1189  .close = cinepak_encode_end,
1191  .priv_class = &cinepak_class,
1192  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1193 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
#define VECTOR_MAX
Definition: cinepakenc.c:57
#define NULL
Definition: coverity.c:32
static enum AVPixelFormat pix_fmt
static const unsigned codebook[256][2]
Definition: cfhdenc.c:41
static int shift(int a, int b)
Definition: sonic.c:82
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void calculate_skip_errors(CinepakEncContext *s, int h, uint8_t *last_data[4], int last_linesize[4], uint8_t *data[4], int linesize[4], strip_info *info)
Definition: cinepakenc.c:813
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
else temp
Definition: vf_mcdeint.c:256
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int cinepak_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: cinepakenc.c:1135
static void write_strip_header(CinepakEncContext *s, int y, int h, int keyframe, unsigned char *buf, int strip_size)
Definition: cinepakenc.c:836
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int strip_number_delta_range
Definition: cinepakenc.c:128
#define MIN_STRIPS
Definition: cinepakenc.c:61
int v1_vector
Definition: cinepakenc.c:88
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
static AVPacket pkt
int v4_vector[4]
Definition: cinepakenc.c:90
#define CVID_HEADER_SIZE
Definition: cinepakenc.c:50
AVCodec.
Definition: codec.h:190
static void get_sub_picture(CinepakEncContext *s, int x, int y, uint8_t *in_data[4], int in_linesize[4], uint8_t *out_data[4], int out_linesize[4])
Definition: cinepakenc.c:430
int v1_codebook[CODEBOOK_MAX *VECTOR_MAX]
Definition: cinepakenc.c:97
#define report
Definition: checkasm.h:126
uint8_t base
Definition: vp3data.h:202
#define VE
Definition: cinepakenc.c:132
#define MAX_STRIPS
Definition: cinepakenc.c:60
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
uint8_t
#define av_cold
Definition: attributes.h:88
static int compute_mb_distortion(CinepakEncContext *s, uint8_t *a_data[4], int a_linesize[4], uint8_t *b_data[4], int b_linesize[4])
Definition: cinepakenc.c:671
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
int * codebook_closest
Definition: cinepakenc.c:119
#define mb
AVFrame * input_frame
Definition: cinepakenc.c:111
AVOptions.
#define CHUNK_HEADER_SIZE
Definition: cinepakenc.c:52
static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, uint8_t *last_data[4], int last_linesize[4], uint8_t *data[4], int linesize[4], uint8_t *scratch_data[4], int scratch_linesize[4], unsigned char *buf, int64_t *best_score)
Definition: cinepakenc.c:854
int avpriv_do_elbg(int *points, int dim, int numpoints, int *codebook, int numCB, int max_steps, int *closest_cb, AVLFG *rand_state)
Implementation of the Enhanced LBG Algorithm Based on the paper "Neural Networks 14:1219-1237" that c...
Definition: elbg.c:371
#define SMALLEST_CODEBOOK
uint8_t * data
Definition: packet.h:363
int v4_codebook[CODEBOOK_MAX *VECTOR_MAX]
Definition: cinepakenc.c:98
ptrdiff_t size
Definition: opengl_enc.c:100
#define CERTAIN(x)
Definition: cinepakenc.c:697
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
#define av_log(a,...)
static const AVOption options[]
Definition: cinepakenc.c:133
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
#define OFFSET(x)
Definition: cinepakenc.c:131
#define U(x)
Definition: vp56_arith.h:37
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define MB_AREA
Definition: cinepakenc.c:55
#define MB_SIZE
Definition: cinepakenc.c:54
unsigned char * frame_buf
Definition: cinepakenc.c:107
static void copy_mb(CinepakEncContext *s, uint8_t *a_data[4], int a_linesize[4], uint8_t *b_data[4], int b_linesize[4])
Definition: cinepakenc.c:506
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
int skip_error
Definition: cinepakenc.c:92
const char * r
Definition: vf_curves.c:114
mb_encoding
Definition: cinepakenc.c:79
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:202
static void decode_v1_vector(CinepakEncContext *s, uint8_t *data[4], int linesize[4], int v1_vector, strip_info *info)
Definition: cinepakenc.c:447
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
common internal API header
MIPS optimizations info
Definition: mips.txt:2
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
int v1_error
Definition: cinepakenc.c:89
static av_cold int cinepak_encode_init(AVCodecContext *avctx)
Definition: cinepakenc.c:154
int width
picture width / height.
Definition: avcodec.h:699
static int write_chunk_header(unsigned char *buf, int chunk_type, int chunk_size)
Definition: cinepakenc.c:375
static void decode_v4_vector(CinepakEncContext *s, uint8_t *data[4], int linesize[4], int *v4_vector, strip_info *info)
Definition: cinepakenc.c:486
int32_t
int v1_size
Definition: cinepakenc.c:99
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:431
int v4_error
Definition: cinepakenc.c:91
if(ret)
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
mb_encoding best_encoding
Definition: cinepakenc.c:93
#define FF_LAMBDA_SCALE
Definition: avutil.h:226
AVFrame * best_frame
Definition: cinepakenc.c:109
int avpriv_init_elbg(int *points, int dim, int numpoints, int *codebook, int numCB, int max_steps, int *closest_cb, AVLFG *rand_state)
Initialize the **codebook vector for the elbg algorithm.
Definition: elbg.c:337
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
main external API structure.
Definition: avcodec.h:526
AVCodec ff_cinepak_encoder
Definition: cinepakenc.c:1181
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
AVFrame * scratch_frame
Definition: cinepakenc.c:110
#define STRIP_HEADER_SIZE
Definition: cinepakenc.c:51
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
static int encode_codebook(CinepakEncContext *s, int *codebook, int size, int chunk_type_yuv, int chunk_type_gray, unsigned char *buf)
Definition: cinepakenc.c:382
static int encode_mode(CinepakEncContext *s, int h, uint8_t *scratch_data[4], int scratch_linesize[4], uint8_t *last_data[4], int last_linesize[4], strip_info *info, unsigned char *buf)
Definition: cinepakenc.c:525
static const AVClass cinepak_class
Definition: cinepakenc.c:147
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
#define flags(name, subs,...)
Definition: cbs_av1.c:560
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
int max_extra_cb_iterations
Definition: cinepakenc.c:124
Y , 8bpp.
Definition: pixfmt.h:74
common internal api header.
common internal and external API header
void * priv_data
Definition: avcodec.h:553
static int quantize(CinepakEncContext *s, int h, uint8_t *data[4], int linesize[4], int v1mode, strip_info *info, mb_encoding encoding)
Definition: cinepakenc.c:698
unsigned char * strip_buf
Definition: cinepakenc.c:107
unsigned char * pict_bufs[4]
Definition: cinepakenc.c:107
static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe, unsigned char *buf, int buf_size)
Definition: cinepakenc.c:986
AVFrame * last_frame
Definition: cinepakenc.c:108
#define av_freep(p)
CinepakMode
Definition: cinepakenc.c:71
#define CODEBOOK_MAX
Definition: cinepakenc.c:58
static int64_t calculate_mode_score(CinepakEncContext *s, int h, strip_info *info, int report, int *training_set_v1_shrunk, int *training_set_v4_shrunk)
Definition: cinepakenc.c:257
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
Definition: common.h:99
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
enum AVPixelFormat pix_fmt
Definition: cinepakenc.c:112
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
static av_cold int cinepak_encode_end(AVCodecContext *avctx)
Definition: cinepakenc.c:1159
for(j=16;j >0;--j)
int i
Definition: input.c:407
CinepakMode mode
Definition: cinepakenc.c:101
static int write_cvid_header(CinepakEncContext *s, unsigned char *buf, int num_strips, int data_size, int isakeyframe)
Definition: cinepakenc.c:974
AVCodecContext * avctx
Definition: cinepakenc.c:106
int keyint_min
minimum GOP size
Definition: avcodec.h:1107