--- /dev/null
+/* putpic.c, block and motion vector encoding routines */
+
+/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
+
+/*
+ * Disclaimer of Warranty
+ *
+ * These software programs are available to the user without any license fee or
+ * royalty on an "as is" basis. The MPEG Software Simulation Group disclaims
+ * any and all warranties, whether express, implied, or statuary, including any
+ * implied warranties or merchantability or of fitness for a particular
+ * purpose. In no event shall the copyright-holder be liable for any
+ * incidental, punitive, or consequential damages of any kind whatsoever
+ * arising from the use of these programs.
+ *
+ * This disclaimer of warranty extends to the user of these programs and user's
+ * customers, employees, agents, transferees, successors, and assigns.
+ *
+ * The MPEG Software Simulation Group does not represent or warrant that the
+ * programs furnished hereunder are free of infringement of any third-party
+ * patents.
+ *
+ * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
+ * are subject to royalty fees to patent holders. Many of these patents are
+ * general enough such that they are unavoidable regardless of implementation
+ * design.
+ *
+ */
+
+#include <stdio.h>
+#include "config.h"
+#include "global.h"
+
+/* output motion vectors (6.2.5.2, 6.3.16.2)
+ *
+ * this routine also updates the predictions for motion vectors (PMV)
+ */
+
+static void putmvs(slice_engine_t *engine,
+ pict_data_s *picture,
+ mbinfo_s *mb,
+ int PMV[2][2][2],
+ int back)
+{
+ int hor_f_code;
+ int vert_f_code;
+
+ if( back )
+ {
+ hor_f_code = picture->back_hor_f_code;
+ vert_f_code = picture->back_vert_f_code;
+ }
+ else
+ {
+ hor_f_code = picture->forw_hor_f_code;
+ vert_f_code = picture->forw_vert_f_code;
+ }
+
+
+ if(picture->pict_struct == FRAME_PICTURE)
+ {
+ if(mb->motion_type == MC_FRAME)
+ {
+/* frame prediction */
+ putmv(engine, mb->MV[0][back][0] - PMV[0][back][0], hor_f_code);
+ putmv(engine, mb->MV[0][back][1] - PMV[0][back][1], vert_f_code);
+ PMV[0][back][0] = PMV[1][back][0] = mb->MV[0][back][0];
+ PMV[0][back][1] = PMV[1][back][1] = mb->MV[0][back][1];
+ }
+ else
+ if (mb->motion_type == MC_FIELD)
+ {
+ /* field prediction */
+ slice_putbits(engine, mb->mv_field_sel[0][back], 1);
+ putmv(engine, mb->MV[0][back][0] - PMV[0][back][0], hor_f_code);
+ putmv(engine, (mb->MV[0][back][1] >> 1) - (PMV[0][back][1] >> 1), vert_f_code);
+ slice_putbits(engine, mb->mv_field_sel[1][back], 1);
+ putmv(engine, mb->MV[1][back][0] - PMV[1][back][0], hor_f_code);
+ putmv(engine, (mb->MV[1][back][1] >> 1) - (PMV[1][back][1] >> 1), vert_f_code);
+ PMV[0][back][0] = mb->MV[0][back][0];
+ PMV[0][back][1] = mb->MV[0][back][1];
+ PMV[1][back][0] = mb->MV[1][back][0];
+ PMV[1][back][1] = mb->MV[1][back][1];
+ }
+ else
+ {
+ /* dual prime prediction */
+ putmv(engine, mb->MV[0][back][0] - PMV[0][back][0], hor_f_code);
+ putdmv(engine, mb->dmvector[0]);
+ putmv(engine, (mb->MV[0][back][1] >> 1) - (PMV[0][back][1] >> 1), vert_f_code);
+ putdmv(engine, mb->dmvector[1]);
+ PMV[0][back][0] = PMV[1][back][0] = mb->MV[0][back][0];
+ PMV[0][back][1] = PMV[1][back][1] = mb->MV[0][back][1];
+ }
+ }
+ else
+ {
+ /* field picture */
+ if(mb->motion_type == MC_FIELD)
+ {
+ /* field prediction */
+ slice_putbits(engine, mb->mv_field_sel[0][back], 1);
+ putmv(engine, mb->MV[0][back][0] - PMV[0][back][0], hor_f_code);
+ putmv(engine, mb->MV[0][back][1] - PMV[0][back][1], vert_f_code);
+ PMV[0][back][0] = PMV[1][back][0] = mb->MV[0][back][0];
+ PMV[0][back][1] = PMV[1][back][1] = mb->MV[0][back][1];
+ }
+ else
+ if(mb->motion_type == MC_16X8)
+ {
+ /* 16x8 prediction */
+ slice_putbits(engine, mb->mv_field_sel[0][back], 1);
+ putmv(engine, mb->MV[0][back][0] - PMV[0][back][0], hor_f_code);
+ putmv(engine, mb->MV[0][back][1] - PMV[0][back][1], vert_f_code);
+ slice_putbits(engine, mb->mv_field_sel[1][back], 1);
+ putmv(engine, mb->MV[1][back][0] - PMV[1][back][0], hor_f_code);
+ putmv(engine, mb->MV[1][back][1] - PMV[1][back][1], vert_f_code);
+ PMV[0][back][0] = mb->MV[0][back][0];
+ PMV[0][back][1] = mb->MV[0][back][1];
+ PMV[1][back][0] = mb->MV[1][back][0];
+ PMV[1][back][1] = mb->MV[1][back][1];
+ }
+ else
+ {
+ /* dual prime prediction */
+ putmv(engine, mb->MV[0][back][0] - PMV[0][back][0], hor_f_code);
+ putdmv(engine, mb->dmvector[0]);
+ putmv(engine, mb->MV[0][back][1] - PMV[0][back][1], vert_f_code);
+ putdmv(engine, mb->dmvector[1]);
+ PMV[0][back][0] = PMV[1][back][0] = mb->MV[0][back][0];
+ PMV[0][back][1] = PMV[1][back][1] = mb->MV[0][back][1];
+ }
+ }
+}
+
+
+void* slice_engine_loop(slice_engine_t *engine)
+{
+ while(!engine->done)
+ {
+ pthread_mutex_lock(&(engine->input_lock));
+
+ if(!engine->done)
+ {
+ pict_data_s *picture = engine->picture;
+ int i, j, k, comp, cc;
+ int mb_type;
+ int PMV[2][2][2];
+ int cbp, MBAinc = 0;
+ short (*quant_blocks)[64] = picture->qblocks;
+
+ k = engine->start_row * mb_width;
+ for(j = engine->start_row; j < engine->end_row; j++)
+ {
+/* macroblock row loop */
+//printf("putpic 1\n");
+//slice_testbits(engine);
+ for(i = 0; i < mb_width; i++)
+ {
+ mbinfo_s *cur_mb = &picture->mbinfo[k];
+ int cur_mb_blocks = k * block_count;
+//pthread_mutex_lock(&test_lock);
+/* macroblock loop */
+ if(i == 0)
+ {
+ slice_alignbits(engine);
+/* slice header (6.2.4) */
+ if(mpeg1 || vertical_size <= 2800)
+ slice_putbits(engine, SLICE_MIN_START + j, 32); /* slice_start_code */
+ else
+ {
+ slice_putbits(engine, SLICE_MIN_START + (j & 127), 32); /* slice_start_code */
+ slice_putbits(engine, j >> 7, 3); /* slice_vertical_position_extension */
+ }
+/* quantiser_scale_code */
+//printf("putpic 1\n");slice_testbits(engine);
+ slice_putbits(engine,
+ picture->q_scale_type ? map_non_linear_mquant_hv[engine->prev_mquant] : engine->prev_mquant >> 1,
+ 5);
+
+ slice_putbits(engine, 0, 1); /* extra_bit_slice */
+
+//printf("putpic 1 %d %d %d\n",engine->prev_mquant, map_non_linear_mquant_hv[engine->prev_mquant], engine->prev_mquant >> 1);
+//slice_testbits(engine);
+ /* reset predictors */
+
+ for(cc = 0; cc < 3; cc++)
+ engine->dc_dct_pred[cc] = 0;
+
+ PMV[0][0][0] = PMV[0][0][1] = PMV[1][0][0] = PMV[1][0][1] = 0;
+ PMV[0][1][0] = PMV[0][1][1] = PMV[1][1][0] = PMV[1][1][1] = 0;
+
+ MBAinc = i + 1; /* first MBAinc denotes absolute position */
+ }
+
+ mb_type = cur_mb->mb_type;
+
+/* determine mquant (rate control) */
+ cur_mb->mquant = ratectl_calc_mquant(engine->ratectl, picture, k);
+
+/* quantize macroblock */
+//printf("putpic 1\n");
+//printf("putpic 1\n");
+//slice_testbits(engine);
+ if(mb_type & MB_INTRA)
+ {
+//printf("putpic 2 %d\n", cur_mb->mquant);
+ quant_intra_hv( picture,
+ picture->blocks[cur_mb_blocks],
+ quant_blocks[cur_mb_blocks],
+ cur_mb->mquant,
+ &cur_mb->mquant );
+
+//printf("putpic 3\n");
+ cur_mb->cbp = cbp = (1<<block_count) - 1;
+ }
+ else
+ {
+//printf("putpic 4 %p %d\n", picture->blocks[cur_mb_blocks], cur_mb_blocks);
+ cbp = (*pquant_non_intra)(picture,
+ picture->blocks[cur_mb_blocks],
+ quant_blocks[cur_mb_blocks],
+ cur_mb->mquant,
+ &cur_mb->mquant);
+//printf("putpic 5\n");
+ cur_mb->cbp = cbp;
+ if (cbp)
+ mb_type|= MB_PATTERN;
+ }
+//printf("putpic 6\n");
+//printf("putpic 2\n");
+//slice_testbits(engine);
+
+/* output mquant if it has changed */
+ if(cbp && engine->prev_mquant != cur_mb->mquant)
+ mb_type |= MB_QUANT;
+
+/* check if macroblock can be skipped */
+ if(i != 0 && i != mb_width - 1 && !cbp)
+ {
+/* no DCT coefficients and neither first nor last macroblock of slice */
+
+ if(picture->pict_type == P_TYPE &&
+ !(mb_type & MB_FORWARD))
+ {
+ /* P picture, no motion vectors -> skip */
+
+ /* reset predictors */
+
+ for(cc = 0; cc < 3; cc++)
+ engine->dc_dct_pred[cc] = 0;
+
+ PMV[0][0][0] = PMV[0][0][1] = PMV[1][0][0] = PMV[1][0][1] = 0;
+ PMV[0][1][0] = PMV[0][1][1] = PMV[1][1][0] = PMV[1][1][1] = 0;
+
+ cur_mb->mb_type = mb_type;
+ cur_mb->skipped = 1;
+ MBAinc++;
+ k++;
+ continue;
+ }
+
+ if(picture->pict_type == B_TYPE &&
+ picture->pict_struct == FRAME_PICTURE &&
+ cur_mb->motion_type == MC_FRAME &&
+ ((picture->mbinfo[k - 1].mb_type ^ mb_type) & (MB_FORWARD | MB_BACKWARD)) == 0 &&
+ (!(mb_type & MB_FORWARD) ||
+ (PMV[0][0][0] == cur_mb->MV[0][0][0] &&
+ PMV[0][0][1] == cur_mb->MV[0][0][1])) &&
+ (!(mb_type & MB_BACKWARD) ||
+ (PMV[0][1][0] == cur_mb->MV[0][1][0] &&
+ PMV[0][1][1] == cur_mb->MV[0][1][1])))
+ {
+/* conditions for skipping in B frame pictures:
+ * - must be frame predicted
+ * - must be the same prediction type (forward/backward/interp.)
+ * as previous macroblock
+ * - relevant vectors (forward/backward/both) have to be the same
+ * as in previous macroblock
+ */
+
+ cur_mb->mb_type = mb_type;
+ cur_mb->skipped = 1;
+ MBAinc++;
+ k++;
+ continue;
+ }
+
+ if (picture->pict_type == B_TYPE &&
+ picture->pict_struct != FRAME_PICTURE &&
+ cur_mb->motion_type == MC_FIELD &&
+ ((picture->mbinfo[k - 1].mb_type ^ mb_type) & (MB_FORWARD | MB_BACKWARD))==0 &&
+ (!(mb_type & MB_FORWARD) ||
+ (PMV[0][0][0] == cur_mb->MV[0][0][0] &&
+ PMV[0][0][1] == cur_mb->MV[0][0][1] &&
+ cur_mb->mv_field_sel[0][0] == (picture->pict_struct == BOTTOM_FIELD))) &&
+ (!(mb_type & MB_BACKWARD) ||
+ (PMV[0][1][0] == cur_mb->MV[0][1][0] &&
+ PMV[0][1][1] == cur_mb->MV[0][1][1] &&
+ cur_mb->mv_field_sel[0][1] == (picture->pict_struct == BOTTOM_FIELD))))
+ {
+/* conditions for skipping in B field pictures:
+ * - must be field predicted
+ * - must be the same prediction type (forward/backward/interp.)
+ * as previous macroblock
+ * - relevant vectors (forward/backward/both) have to be the same
+ * as in previous macroblock
+ * - relevant motion_vertical_field_selects have to be of same
+ * parity as current field
+ */
+
+ cur_mb->mb_type = mb_type;
+ cur_mb->skipped = 1;
+ MBAinc++;
+ k++;
+ continue;
+ }
+ }
+//printf("putpic 3\n");
+//slice_testbits(engine);
+
+/* macroblock cannot be skipped */
+ cur_mb->skipped = 0;
+
+/* there's no VLC for 'No MC, Not Coded':
+ * we have to transmit (0,0) motion vectors
+ */
+ if(picture->pict_type == P_TYPE &&
+ !cbp &&
+ !(mb_type & MB_FORWARD))
+ mb_type |= MB_FORWARD;
+
+/* macroblock_address_increment */
+ putaddrinc(engine, MBAinc);
+ MBAinc = 1;
+ putmbtype(engine, picture->pict_type, mb_type); /* macroblock type */
+//printf("putpic 3\n");
+//slice_testbits(engine);
+
+ if(mb_type & (MB_FORWARD | MB_BACKWARD) &&
+ !picture->frame_pred_dct)
+ slice_putbits(engine, cur_mb->motion_type, 2);
+
+//printf("putpic %x %d %d %d\n", mb_type, picture->pict_struct, cbp, picture->frame_pred_dct);
+ if(picture->pict_struct == FRAME_PICTURE &&
+ cbp &&
+ !picture->frame_pred_dct)
+ slice_putbits(engine, cur_mb->dct_type, 1);
+
+ if(mb_type & MB_QUANT)
+ {
+ slice_putbits(engine,
+ picture->q_scale_type ? map_non_linear_mquant_hv[cur_mb->mquant] : cur_mb->mquant >> 1,
+ 5);
+ engine->prev_mquant = cur_mb->mquant;
+ }
+
+ if(mb_type & MB_FORWARD)
+ {
+/* forward motion vectors, update predictors */
+ putmvs(engine, picture, cur_mb, PMV, 0);
+ }
+
+ if(mb_type & MB_BACKWARD)
+ {
+/* backward motion vectors, update predictors */
+ putmvs(engine, picture, cur_mb, PMV, 1);
+ }
+
+ if(mb_type & MB_PATTERN)
+ {
+ putcbp(engine, (cbp >> (block_count - 6)) & 63);
+ if(chroma_format != CHROMA420)
+ slice_putbits(engine, cbp, block_count - 6);
+ }
+
+//printf("putpic 4\n");
+//slice_testbits(engine);
+
+ for(comp = 0; comp < block_count; comp++)
+ {
+/* block loop */
+ if(cbp & (1 << (block_count - 1 - comp)))
+ {
+ if(mb_type & MB_INTRA)
+ {
+ cc = (comp < 4) ? 0 : (comp & 1) + 1;
+ putintrablk(engine, picture, quant_blocks[cur_mb_blocks + comp], cc);
+
+ }
+ else
+ putnonintrablk(engine, picture, quant_blocks[cur_mb_blocks + comp]);
+ }
+ }
+//printf("putpic 5\n");
+//slice_testbits(engine);
+//sleep(1);
+
+ /* reset predictors */
+ if(!(mb_type & MB_INTRA))
+ for(cc = 0; cc < 3; cc++)
+ engine->dc_dct_pred[cc] = 0;
+
+ if(mb_type & MB_INTRA ||
+ (picture->pict_type == P_TYPE && !(mb_type & MB_FORWARD)))
+ {
+ PMV[0][0][0] = PMV[0][0][1] = PMV[1][0][0] = PMV[1][0][1] = 0;
+ PMV[0][1][0] = PMV[0][1][1] = PMV[1][1][0] = PMV[1][1][1] = 0;
+ }
+
+ cur_mb->mb_type = mb_type;
+ k++;
+//pthread_mutex_unlock(&test_lock);
+ }
+ }
+ }
+ pthread_mutex_unlock(&(engine->output_lock));
+ }
+}
+
+
+/* quantization / variable length encoding of a complete picture */
+void putpict(pict_data_s *picture)
+{
+ int i, prev_mquant;
+
+ for(i = 0; i < processors; i++)
+ {
+ ratectl_init_pict(ratectl[i], picture); /* set up rate control */
+ }
+
+/* picture header and picture coding extension */
+ putpicthdr(picture);
+ if(!mpeg1) putpictcodext(picture);
+/* Flush buffer before switching to slice mode */
+ alignbits();
+
+/* Start loop */
+ for(i = 0; i < processors; i++)
+ {
+ slice_engines[i].prev_mquant = ratectl_start_mb(ratectl[i], picture);
+ slice_engines[i].picture = picture;
+ slice_engines[i].ratectl = ratectl[i];
+ slice_initbits(&slice_engines[i]);
+
+ pthread_mutex_unlock(&(slice_engines[i].input_lock));
+ }
+
+/* Wait for completion and write slices */
+ for(i = 0; i < processors; i++)
+ {
+ pthread_mutex_lock(&(slice_engines[i].output_lock));
+ slice_finishslice(&slice_engines[i]);
+ }
+
+ for(i = 0; i < processors; i++)
+ ratectl_update_pict(ratectl[i], picture);
+}
+
+void start_slice_engines()
+{
+ int i;
+ int rows_per_processor = (int)((float)mb_height2 / processors + 0.5);
+ int current_row = 0;
+ pthread_attr_t attr;
+ pthread_mutexattr_t mutex_attr;
+
+ pthread_mutexattr_init(&mutex_attr);
+ pthread_attr_init(&attr);
+// pthread_mutex_init(&test_lock, &mutex_attr);
+
+ slice_engines = calloc(1, sizeof(slice_engine_t) * processors);
+ for(i = 0; i < processors; i++)
+ {
+ slice_engines[i].start_row = current_row;
+ current_row += rows_per_processor;
+ if(current_row > mb_height2) current_row = mb_height2;
+ slice_engines[i].end_row = current_row;
+
+ pthread_mutex_init(&(slice_engines[i].input_lock), &mutex_attr);
+ pthread_mutex_lock(&(slice_engines[i].input_lock));
+ pthread_mutex_init(&(slice_engines[i].output_lock), &mutex_attr);
+ pthread_mutex_lock(&(slice_engines[i].output_lock));
+ slice_engines[i].done = 0;
+ pthread_create(&(slice_engines[i].tid),
+ &attr,
+ (void*)slice_engine_loop,
+ &slice_engines[i]);
+ }
+}
+
+void stop_slice_engines()
+{
+ int i;
+ for(i = 0; i < processors; i++)
+ {
+ slice_engines[i].done = 1;
+ pthread_mutex_unlock(&(slice_engines[i].input_lock));
+ pthread_join(slice_engines[i].tid, 0);
+ pthread_mutex_destroy(&(slice_engines[i].input_lock));
+ pthread_mutex_destroy(&(slice_engines[i].output_lock));
+ if(slice_engines[i].slice_buffer) free(slice_engines[i].slice_buffer);
+ }
+ free(slice_engines);
+// pthread_mutex_destroy(&test_lock);
+}
projects / goodguy / history.git / blobdiff