/****************************************************************************** * gst_ticircbuffer_shift_data * Look for uncopied data in the last window and move it to the first one. ******************************************************************************/ static gboolean gst_ticircbuffer_shift_data(GstTICircBuffer *circBuf) { Int8* firstWindow = Buffer_getUserPtr(circBuf->hBuf); Int32 lastWinOffset = Buffer_getSize(circBuf->hBuf) - (circBuf->windowSize + circBuf->readAheadSize); Int8* lastWindow = firstWindow + lastWinOffset; Int32 bytesToCopy = 0; gboolean writePtrReset = FALSE; /* In fixedBlockSize mode, just wait until the write poitner reaches the * end of the buffer and then reset it to the beginning (no copying). */ if (circBuf->fixedBlockSize && circBuf->writePtr >= circBuf->readPtr) { if (circBuf->writePtr == firstWindow + Buffer_getSize(circBuf->hBuf)) { GST_LOG("resetting write pointer (%lu->0)\n", (UInt32)(circBuf->writePtr - firstWindow)); circBuf->writePtr = Buffer_getUserPtr(circBuf->hBuf); circBuf->contiguousData = FALSE; } return TRUE; } /* Otherwise copy unconsumed data from the last window to the first one * and reset the write pointer back to the first window. */ if (gst_ticircbuffer_first_window_free(circBuf) && circBuf->writePtr >= circBuf->readPtr && circBuf->writePtr >= lastWindow + circBuf->windowSize) { bytesToCopy = circBuf->writePtr - lastWindow; GST_LOG("shifting %lu bytes of data from %lu to 0\n", bytesToCopy, (UInt32)(lastWindow - firstWindow)); if (bytesToCopy > 0) { memcpy(firstWindow, lastWindow, bytesToCopy); } GST_LOG("resetting write pointer (%lu->%lu)\n", (UInt32)(circBuf->writePtr - firstWindow), (UInt32)(circBuf->writePtr - (lastWindow - firstWindow) - firstWindow)); circBuf->writePtr -= (lastWindow - firstWindow); circBuf->contiguousData = FALSE; writePtrReset = TRUE; /* The queue function will not unblock the consumer until there is * at least windowSize + readAhead available, but if the read pointer * is toward the end of the buffer, we may never get more than just * windowSize available and will deadlock. To avoid this situation, * wake the consumer after shifting data so it has an opportunity to * process the last window in the buffer and reset itself to the * beginning of the buffer. */ gst_ticircbuffer_broadcast_producer(circBuf); } return writePtrReset; }
/****************************************************************************** * readFrame420P ******************************************************************************/ Int readFrame420P(Buffer_Handle hBuf, FILE *outFile, Int imageHeight) { Int8 *yPtr = Buffer_getUserPtr(hBuf); Int8 *cbcrPtr; Int y, x; BufferGfx_Dimensions dim; BufferGfx_getDimensions(hBuf, &dim); /* Write Y plane */ for (y = 0; y < imageHeight; y++) { if (fread(yPtr, dim.width, 1, outFile) != 1) { fprintf(stderr,"Failed to read data from file\n"); return -1; } yPtr += dim.lineLength; } /* Join Cb to CbCr interleaved */ cbcrPtr = Buffer_getUserPtr(hBuf) + Buffer_getSize(hBuf) * 2 / 3; for (y = 0; y < imageHeight / 2; y++) { for (x = 0; x < dim.width; x += 2) { if (fread(&cbcrPtr[x], 1, 1, outFile) != 1) { fprintf(stderr,"Failed to read data from file\n"); return -1; } } cbcrPtr += dim.lineLength; } /* Join Cr to CbCr interleaved */ cbcrPtr = Buffer_getUserPtr(hBuf) + Buffer_getSize(hBuf) * 2 / 3; for (y = 0; y < imageHeight / 2; y++) { for (x = 1; x < dim.width; x += 2) { if (fread(&cbcrPtr[x], 1, 1, outFile) != 1) { fprintf(stderr,"Failed to read data from file\n"); return -1; } } cbcrPtr += dim.lineLength; } printf("Read 420P frame size %d (%dx%d) from file\n", (Int) (dim.width * 3 / 2 * imageHeight), (Int) dim.width, (Int) imageHeight); Buffer_setNumBytesUsed(hBuf, Buffer_getSize(hBuf)); return 0; }
/****************************************************************************** * Resize_execute ******************************************************************************/ Int Resize_execute(Resize_Handle hResize, Buffer_Handle hSrcBuf, Buffer_Handle hDstBuf) { #ifdef CONFIG_DM365_IPIPE struct imp_convert rsz; BufferGfx_Dimensions srcDim; BufferGfx_Dimensions dstDim; UInt32 srcOffset; UInt32 dstOffset; assert(hResize); assert(hSrcBuf); assert(hDstBuf); Dmai_clear(rsz); BufferGfx_getDimensions(hSrcBuf, &srcDim); BufferGfx_getDimensions(hDstBuf, &dstDim); srcOffset = srcDim.y * srcDim.lineLength + (srcDim.x << 1); dstOffset = dstDim.y * dstDim.lineLength + (dstDim.x << 1); rsz.in_buff.index = -1; rsz.in_buff.buf_type = IMP_BUF_IN; rsz.in_buff.offset = (UInt32) Buffer_getUserPtr(hSrcBuf) + srcOffset; rsz.in_buff.size = Buffer_getSize(hSrcBuf); rsz.out_buff1.index = -1; rsz.out_buff1.buf_type = IMP_BUF_OUT1; rsz.out_buff1.offset = (UInt32) Buffer_getUserPtr(hDstBuf) + dstOffset; rsz.out_buff1.size = Buffer_getSize(hDstBuf); /* * The IPIPE requires that the memory offsets of the input and output * buffers start on 32-byte boundaries. */ assert((rsz.in_buff.offset & 0x1F) == 0); assert((rsz.out_buff1.offset & 0x1F) == 0); /* Start IPIPE operation */ if (ioctl(hResize->fd, RSZ_RESIZE, &rsz) == -1) { Dmai_err0("Failed RSZ_RESIZE\n"); return Dmai_EFAIL; } Buffer_setNumBytesUsed(hDstBuf, Buffer_getNumBytesUsed(hSrcBuf)); return Dmai_EOK; #else Dmai_err0("not implemented\n"); return Dmai_ENOTIMPL; #endif }
/***************************************************************************** * gst_tiprepencbuf_prepare_output_buffer * Function is used to allocate output buffer *****************************************************************************/ static GstFlowReturn gst_tiprepencbuf_prepare_output_buffer(GstBaseTransform * trans, GstBuffer * inBuf, gint size, GstCaps * caps, GstBuffer ** outBuf) { GstTIPrepEncBuf *prepencbuf = GST_TIPREPENCBUF(trans); Buffer_Handle hOutBuf; GST_LOG("begin prepare output buffer\n"); /* Get free buffer from buftab */ if (!(hOutBuf = gst_tidmaibuftab_get_buf(prepencbuf->hOutBufTab))) { GST_ELEMENT_ERROR(prepencbuf, RESOURCE, READ, ("failed to get free buffer\n"), (NULL)); return GST_FLOW_ERROR; } /* Create a DMAI transport buffer object to carry a DMAI buffer to * the source pad. The transport buffer knows how to release the * buffer for re-use in this element when the source pad calls * gst_buffer_unref(). */ GST_LOG("creating dmai transport buffer\n"); *outBuf = gst_tidmaibuffertransport_new(hOutBuf, prepencbuf->hOutBufTab, NULL, NULL); gst_buffer_set_data(*outBuf, (guint8 *) Buffer_getUserPtr(hOutBuf), Buffer_getSize(hOutBuf)); gst_buffer_set_caps(*outBuf, GST_PAD_CAPS(trans->srcpad)); GST_LOG("end prepare output buffer\n"); return GST_FLOW_OK; }
/****************************************************************************** * Sound_alsa_read ******************************************************************************/ Int Sound_alsa_read(Sound_Handle hSound, Buffer_Handle hBuf) { Int32 numSamples, readSamples; Int8 *bufPtr; assert(hSound); assert(hBuf); readSamples = Buffer_getNumBytesUsed(hBuf) / (2 * hSound->channels); bufPtr = Buffer_getUserPtr(hBuf); while (readSamples > 0) { numSamples = snd_pcm_readi(hSound->rcIn, bufPtr, readSamples); if (numSamples == -EAGAIN) continue; if (numSamples < 0) { if (xrunRecovery(hSound->rcIn,numSamples) < 0) { Dmai_err2 ("Failed to read from %s (%s)\n", AUDIO_DEVICE, strerror(numSamples)); return Dmai_EFAIL; } } else { bufPtr += numSamples * 2 * hSound->channels; readSamples -= numSamples; } } Buffer_setNumBytesUsed(hBuf, Buffer_getSize(hBuf)); return Dmai_EOK; }
/****************************************************************************** * gst_ticircbuffer_write_space * Return the free space available in the buffer for CONTIGUOUS WRITING at * the writePtr location. ******************************************************************************/ static Int32 gst_ticircbuffer_write_space(GstTICircBuffer *circBuf) { if (circBuf->contiguousData) { return (Buffer_getUserPtr(circBuf->hBuf) + Buffer_getSize(circBuf->hBuf)) - circBuf->writePtr; } return circBuf->readPtr - circBuf->writePtr; }
/****************************************************************************** * gst_ticircbuffer_data_size * Return the total amount of data currently in the buffer (may not all be * contiguous in memory). ******************************************************************************/ static Int32 gst_ticircbuffer_data_size(GstTICircBuffer *circBuf) { if (gst_ticircbuffer_is_empty(circBuf)) { return 0; } return (circBuf->contiguousData) ? (circBuf->writePtr - circBuf->readPtr) : Buffer_getSize(circBuf->hBuf) - (circBuf->readPtr - circBuf->writePtr); }
void dmaiaccel_release_cb(gpointer data, GstTIDmaiBufferTransport *buf){ Buffer_Handle hBuf = GST_TIDMAIBUFFERTRANSPORT_DMAIBUF(buf); GstBuffer *inBuf = (GstBuffer *)data; GST_DEBUG("Release callback for dmaiaccel allocated buffer"); Memory_unregisterContigBuf((UInt32)Buffer_getUserPtr(hBuf), Buffer_getSize(hBuf)); /* Now we can release our input buffer */ gst_buffer_unref(inBuf); }
/****************************************************************************** * gst_ticircbuffer_reset_read_pointer * Reset the read pointer back to the beginning of the buffer. ******************************************************************************/ static Int32 gst_ticircbuffer_reset_read_pointer(GstTICircBuffer *circBuf) { Int8 *circBufStart = Buffer_getUserPtr(circBuf->hBuf); Int32 lastWinOffset = Buffer_getSize(circBuf->hBuf) - (circBuf->windowSize + circBuf->readAheadSize); Int8 *lastWindow = circBufStart + lastWinOffset; Int32 resetDelta = lastWindow - circBufStart; /* In fixedBlockSize mode, just wait until the read poitner reaches the * end of the buffer and then reset it to the beginning. */ if (circBuf->fixedBlockSize && !circBuf->contiguousData) { if (circBuf->readPtr == circBufStart + Buffer_getSize(circBuf->hBuf)) { GST_LOG("resetting read pointer (%lu->0)\n", (UInt32)(circBuf->readPtr - circBufStart)); circBuf->readPtr = Buffer_getUserPtr(circBuf->hBuf); circBuf->contiguousData = TRUE; } return 0; } /* Otherwise, reset it when the read pointer reaches the last window and * the last window has already been copied back to the first window. */ if (!circBuf->contiguousData && circBuf->readPtr > lastWindow && circBuf->readPtr - resetDelta <= circBuf->writePtr) { GST_LOG("resetting read pointer (%lu->%lu)\n", (UInt32)(circBuf->readPtr - circBufStart), (UInt32)(circBuf->readPtr - resetDelta - circBufStart)); circBuf->readPtr -= resetDelta; circBuf->contiguousData = TRUE; return TRUE; } return FALSE; }
/****************************************************************************** * cleanup ******************************************************************************/ static Int cleanup(Display_Handle hDisplay) { Int ret = Dmai_EOK; BufTab_Handle hBufTab = hDisplay->hBufTab; enum v4l2_buf_type type; Int bufIdx; Buffer_Handle hDispBuf; if (hDisplay->fd != -1) { if (hDisplay->started) { /* Shut off the video display */ type = V4L2_BUF_TYPE_VIDEO_OUTPUT; if (ioctl(hDisplay->fd, VIDIOC_STREAMOFF, &type) == -1) { Dmai_err1("VIDIOC_STREAMOFF failed (%s)\n", strerror(errno)); ret = Dmai_EFAIL; } } if (close(hDisplay->fd) == -1) { Dmai_err1("Failed to close capture device (%s)\n", strerror(errno)); ret = Dmai_EIO; } if (hDisplay->userAlloc == FALSE) { if (hBufTab) { for (bufIdx = 0; bufIdx < BufTab_getNumBufs(hBufTab); bufIdx++) { hDispBuf = BufTab_getBuf(hBufTab, bufIdx); if (munmap(Buffer_getUserPtr(hDispBuf), Buffer_getSize(hDispBuf)) == -1) { Dmai_err1("Failed to unmap capture buffer%d\n", bufIdx); ret = Dmai_EFAIL; } } } } } if (hDisplay->bufDescs) { free(hDisplay->bufDescs); } free(hDisplay); return ret; }
/****************************************************************************** * cleanup ******************************************************************************/ static Int cleanup(Capture_Handle hCapture) { BufTab_Handle hBufTab = hCapture->hBufTab; Int ret = Dmai_EOK; Int8 *capBufPtr; enum v4l2_buf_type type; Uns bufIdx; Buffer_Handle hCapBuf; if (hCapture->fd != -1) { if (hCapture->started) { /* Shut off the video capture */ type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if (ioctl(hCapture->fd, VIDIOC_STREAMOFF, &type) == -1) { Dmai_err1("VIDIOC_STREAMOFF failed (%s)\n", strerror(errno)); ret = Dmai_EFAIL; } } if (close(hCapture->fd) == -1) { Dmai_err1("Failed to close capture device (%s)\n", strerror(errno)); ret = Dmai_EIO; } if (hCapture->userAlloc == FALSE && hBufTab) { for (bufIdx = 0; bufIdx < BufTab_getNumBufs(hBufTab); bufIdx++) { hCapBuf = BufTab_getBuf(hBufTab, bufIdx); capBufPtr = Buffer_getUserPtr(hCapBuf); if (munmap(capBufPtr - hCapture->topOffset, Buffer_getSize(hCapBuf)) == -1) { Dmai_err1("Failed to unmap capture buffer%d\n", bufIdx); ret = Dmai_EFAIL; } } } if (hCapture->bufDescs) { free(hCapture->bufDescs); } } free(hCapture); return ret; }
/****************************************************************************** * setOsdTransparency ******************************************************************************/ static Int setOsdTransparency(UI_Handle hUI, Char trans) { Buffer_Handle hBuf; if (Display_get(hUI->hAttr, &hBuf) < 0) { ERR("Failed to get attribute window buffer\n"); return FAILURE; } memset(Buffer_getUserPtr(hBuf), trans, Buffer_getSize(hBuf)); if (Display_put(hUI->hAttr, hBuf) < 0) { ERR("Failed to put display buffer\n"); return FAILURE; } return SUCCESS; }
/****************************************************************************** * Sound_alsa_write ******************************************************************************/ Int Sound_alsa_write(Sound_Handle hSound, Buffer_Handle hBuf) { Int32 numSamples, writeSamples; Int8 *bufPtr; assert(hSound); assert(hBuf); writeSamples = Buffer_getNumBytesUsed(hBuf) / (2 * hSound->channels); bufPtr = Buffer_getUserPtr(hBuf); while (writeSamples > 0) { /* start by doing a blocking wait for free space. */ snd_pcm_wait (hSound->rcOut, PCM_TIMEOUT); numSamples = snd_pcm_writei(hSound->rcOut, bufPtr, writeSamples); if (numSamples == -EAGAIN) continue; if (numSamples < 0) { if (xrunRecovery(hSound->rcOut,numSamples) < 0) { Dmai_err2 ("Failed to write to %s (%s)\n", AUDIO_DEVICE, strerror(-numSamples)); return Dmai_EFAIL; } } else { bufPtr += numSamples * 2 * hSound->channels; writeSamples -= numSamples; } } Buffer_setNumBytesUsed(hBuf, Buffer_getSize(hBuf)); return Dmai_EOK; }
/****************************************************************************** * gst_ticircbuffer_data_available * Return how much contiguous data is available at the read pointer. ******************************************************************************/ static Int32 gst_ticircbuffer_data_available(GstTICircBuffer *circBuf) { /* First check if the buffer is empty, in which case return 0. */ if (gst_ticircbuffer_is_empty(circBuf)) { return 0; } /* If the write pointer is now ahead of the read pointer, make sure there * is a window available. */ if (circBuf->contiguousData) { return (circBuf->writePtr - circBuf->readPtr); } /* Otherwise, there needs to be enough data between the read pointer and * the end of the buffer. */ else { return (Buffer_getUserPtr(circBuf->hBuf) + Buffer_getSize(circBuf->hBuf)) - circBuf->readPtr; } return 0; }
Void CapBuf_blackFill(Buffer_Handle hBuf) { switch (BufferGfx_getColorSpace(hBuf)) { case ColorSpace_YUV422PSEMI: { Int8 *yPtr = Buffer_getUserPtr(hBuf); Int32 ySize = Buffer_getSize(hBuf) / 2; Int8 *cbcrPtr = yPtr + ySize; Int bpp = ColorSpace_getBpp(ColorSpace_YUV422PSEMI); Int y; BufferGfx_Dimensions dim; UInt32 offset; BufferGfx_getDimensions(hBuf, &dim); offset = dim.y * dim.lineLength + dim.x * bpp / 8; for (y = 0; y < dim.height; y++) { memset(yPtr + offset, 0x0, dim.width * bpp / 8); yPtr += dim.lineLength; } for (y = 0; y < dim.height; y++) { memset(cbcrPtr + offset, 0x80, dim.width * bpp / 8); cbcrPtr += dim.lineLength; } break; } case ColorSpace_YUV420PSEMI: { Int8 *yPtr = Buffer_getUserPtr(hBuf); Int32 ySize = Buffer_getSize(hBuf) * 2 / 3; Int8 *cbcrPtr = yPtr + ySize; Int bpp = ColorSpace_getBpp(ColorSpace_YUV420PSEMI); Int y; BufferGfx_Dimensions dim; BufferGfx_getDimensions(hBuf, &dim); yPtr += dim.y * dim.lineLength + dim.x * bpp / 8; for (y = 0; y < dim.height; y++) { memset(yPtr, 0x0, dim.width * bpp / 8); yPtr += dim.lineLength; } cbcrPtr += dim.y * dim.lineLength / 2 + dim.x * bpp / 8; for (y = 0; y < dim.height / 2; y++) { memset(cbcrPtr, 0x80, dim.width * bpp / 8); cbcrPtr += dim.lineLength; } break; } case ColorSpace_UYVY: { Int32 *bufPtr = (Int32*)Buffer_getUserPtr(hBuf); Int bpp = ColorSpace_getBpp(ColorSpace_UYVY); Int i, j; BufferGfx_Dimensions dim; BufferGfx_getDimensions(hBuf, &dim); bufPtr += (dim.y * dim.lineLength + dim.x * bpp / 8) / sizeof(Int32); /* Make sure display buffer is 4-byte aligned */ assert((((UInt32) bufPtr) & 0x3) == 0); for (i = 0; i < dim.height; i++) { for (j = 0; j < dim.width / 2; j++) { bufPtr[j] = UYVY_BLACK; } bufPtr += dim.lineLength / sizeof(Int32); } break; } case ColorSpace_RGB565: { memset(Buffer_getUserPtr(hBuf), 0, Buffer_getSize(hBuf)); break; } default: { ERR("Unsupported color space (%d) for _Dmai_blackFill\n", BufferGfx_getColorSpace(hBuf)); break; } } }
/****************************************************************************** * Framecopy_accel_execute ******************************************************************************/ Int Framecopy_accel_execute(Framecopy_Handle hFc, Buffer_Handle hSrcBuf, Buffer_Handle hDstBuf) { vdce_address_start_t params; BufferGfx_Dimensions srcDim; BufferGfx_Dimensions dstDim; UInt32 srcOffset, dstOffset; assert(hFc); assert(hSrcBuf); assert(hDstBuf); /* VDCE addresses must be a multiple of 8 */ assert((((UInt32) Buffer_getUserPtr(hDstBuf)) & 0x7) == 0); assert((((UInt32) Buffer_getUserPtr(hSrcBuf)) & 0x7) == 0); /* Buffer sizes / 4 must be a multiple of 8 */ assert(((Buffer_getSize(hSrcBuf) / 4) & 0x7) == 0); assert(((Buffer_getSize(hDstBuf) / 4) & 0x7) == 0); BufferGfx_getDimensions(hSrcBuf, &srcDim); BufferGfx_getDimensions(hDstBuf, &dstDim); assert(srcDim.x >= 0); assert(srcDim.y >= 0); assert(dstDim.x >= 0); assert(dstDim.y >= 0); assert((srcDim.x & 0x7) == 0); assert((dstDim.x & 0x7) == 0); srcOffset = srcDim.y * srcDim.lineLength + srcDim.x; dstOffset = dstDim.y * dstDim.lineLength + dstDim.x; params.buffers[VDCE_BUF_IN].index = -1; params.buffers[VDCE_BUF_IN].buf_type = VDCE_BUF_IN; params.buffers[VDCE_BUF_IN].virt_ptr = ((Int32) Buffer_getUserPtr(hSrcBuf)+ srcOffset); params.buffers[VDCE_BUF_IN].size = Buffer_getSize(hSrcBuf); params.buffers[VDCE_BUF_OUT].index = -1; params.buffers[VDCE_BUF_OUT].buf_type = VDCE_BUF_OUT; params.buffers[VDCE_BUF_OUT].virt_ptr = ((Int32) Buffer_getUserPtr(hDstBuf)+ dstOffset); params.buffers[VDCE_BUF_OUT].size = Buffer_getSize(hDstBuf); params.src_horz_pitch = srcDim.lineLength; params.res_horz_pitch = dstDim.lineLength; if (ioctl(hFc->fd, VDCE_START, ¶ms) < 0) { Dmai_err0("Failed VDCE_START\n"); return Dmai_EFAIL; } if (BufferGfx_getColorSpace(hDstBuf) == ColorSpace_YUV420PSEMI) { Buffer_setNumBytesUsed(hDstBuf, dstDim.width * dstDim.height * 3 / 2); } else { Buffer_setNumBytesUsed(hDstBuf, dstDim.width * dstDim.height * 2); } return Dmai_EOK; }
/****************************************************************************** * appMain ******************************************************************************/ Void appMain(Args * args) { Buffer_Attrs bAttrs = Buffer_Attrs_DEFAULT; Time_Attrs tAttrs = Time_Attrs_DEFAULT; SPHENC1_Params params = Senc1_Params_DEFAULT; SPHENC1_DynamicParams dynParams = Senc1_DynamicParams_DEFAULT; Senc1_Handle hSe1 = NULL; Engine_Handle hEngine = NULL; Buffer_Handle hOutBuf = NULL; Buffer_Handle hInBuf = NULL; Time_Handle hTime = NULL; FILE *inFile = NULL; FILE *outFile = NULL; Int numFrame = 0; Int32 bytesRead; UInt32 time; printf("Starting application...\n"); if (args->benchmark) { hTime = Time_create(&tAttrs); if (hTime == NULL) { printf("Failed to create Time object\n"); goto cleanup; } } /* Initialize the codec engine run time */ CERuntime_init(); /* Initialize DMAI */ Dmai_init(); /* Open the output file */ outFile = fopen(args->outFile, "wb"); if (outFile == NULL) { printf("Failed to create output file %s\n", args->outFile); goto cleanup; } /* Open the input file */ inFile = fopen(args->inFile, "rb"); if (inFile == NULL) { printf("Failed to open input file %s\n", args->inFile); goto cleanup; } /* Using a larger vbuf to enhance performance of file i/o */ if (setvbuf(outFile, vbuffer, _IOFBF, sizeof(vbuffer)) != 0) { printf("Failed to setvbuf on file descriptor\n"); goto cleanup; } /* Open the codec engine */ hEngine = Engine_open(args->engineName, NULL, NULL); if (hEngine == NULL) { printf("Failed to open codec engine %s\n", args->engineName); goto cleanup; } params.compandingLaw = args->compandingLaw; /* Create the SPHENC1 based speech encoder */ hSe1 = Senc1_create(hEngine, args->codecName, ¶ms, &dynParams); if (hSe1 == NULL) { printf("Failed to create %s\n", args->codecName); goto cleanup; } /* Align buffers to cache line boundary */ bAttrs.memParams.align = BUFSIZEALIGN; /* Use cached buffers if requested */ if (args->cache) { bAttrs.memParams.flags = Memory_CACHED; } /* Create an output buffer for encoded data */ hOutBuf = Buffer_create( Dmai_roundUp(Senc1_getOutBufSize(hSe1), BUFSIZEALIGN), &bAttrs); if (hOutBuf == NULL) { printf("Failed to create contiguous buffer\n"); goto cleanup; } /* Create an input buffer for input data */ hInBuf = Buffer_create(Dmai_roundUp(Senc1_getInBufSize(hSe1), BUFSIZEALIGN), &bAttrs); if (hInBuf == NULL) { printf("Failed to create contiguous buffer\n"); goto cleanup; } while (numFrame++ < args->numFrames) { printf("Frame %d: ", numFrame); if (args->benchmark) { if (Time_reset(hTime) < 0) { printf("Failed to reset timer\n"); goto cleanup; } } /* Read raw PCM data from input file */ bytesRead = fread(Buffer_getUserPtr(hInBuf), 1, Senc1_getInBufSize(hSe1), inFile); if (bytesRead < Senc1_getInBufSize(hSe1)) { if (ferror(inFile)) { printf("Failed to read data from input file\n"); goto cleanup; } printf("Failed to read full frame %ld bytes, read %ld bytes\n", Senc1_getInBufSize(hSe1),bytesRead); goto cleanup; } Buffer_setNumBytesUsed(hInBuf, bytesRead); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { printf("Failed to get timer delta\n"); goto cleanup; } printf("Read: %uus ", (Uns) time); } if (args->cache) { /* * To meet xDAIS DMA Rule 7, when input buffers are cached, we * must writeback the cache into physical memory. Also, per DMA * Rule 7, we must invalidate the output buffer from * cache before providing it to any xDAIS algorithm. */ Memory_cacheWbInv(Buffer_getUserPtr(hInBuf), Buffer_getSize(hInBuf)); /* Per DMA Rule 7, our output buffer cache lines must be cleaned */ Memory_cacheInv(Buffer_getUserPtr(hOutBuf), Buffer_getSize(hOutBuf)); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { printf("Failed to get timer delta\n"); goto cleanup; } printf("Pre-process cache maintenance: %uus ", (Uns) time); } } /* Encode the speech buffer */ if (Senc1_process(hSe1, hInBuf, hOutBuf) < 0) { printf("Failed to encode speech buffer\n"); goto cleanup; } if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { printf("Failed to get timer delta\n"); goto cleanup; } printf("Encode: %uus ", (Uns) time); } if (args->cache) { /* Writeback the outBuf. */ Memory_cacheWb(Buffer_getUserPtr(hOutBuf), Buffer_getSize(hOutBuf)); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { printf("Failed to get timer delta\n"); goto cleanup; } printf("Post-process cache write back: %uus ", (Uns) time); } } printf("Write encoded speech data to output file \n"); /* Write the encoded frame to the file system */ if (Buffer_getNumBytesUsed(hOutBuf)) { if (fwrite(Buffer_getUserPtr(hOutBuf), Buffer_getNumBytesUsed(hOutBuf), 1, outFile) != 1) { printf("Failed to write encoded speech data to file\n"); goto cleanup; } } if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { printf("Failed to get timer delta\n"); goto cleanup; } printf("Write: %uus ", (Uns) time); if (Time_total(hTime, &time) < 0) { printf("Failed to get timer total\n"); goto cleanup; } printf("Total: %uus\n", (unsigned int)time); } } cleanup: /* Clean up the application */ if (hSe1) { Senc1_delete(hSe1); } if (hInBuf) { Buffer_delete(hInBuf); } if (hOutBuf) { Buffer_delete(hOutBuf); } if (hEngine) { Engine_close(hEngine); } if (hTime) { Time_delete(hTime); } if (inFile) { fclose(inFile); } if (outFile) { fclose(outFile); } printf("End of application.\n"); return; }
/****************************************************************************** * _Dmai_blackFill ******************************************************************************/ Void _Dmai_blackFill(Buffer_Handle hBuf) { switch (BufferGfx_getColorSpace(hBuf)) { case ColorSpace_YUV422PSEMI: { Int8 *yPtr = Buffer_getUserPtr(hBuf); Int32 ySize = Buffer_getSize(hBuf) / 2; Int8 *cbcrPtr = yPtr + ySize; Int32 cbCrSize = Buffer_getSize(hBuf) - ySize; Int i; /* Fill the Y plane */ for (i = 0; i < ySize; i++) { yPtr[i] = 0x0; } for (i = 0; i < cbCrSize; i++) { cbcrPtr[i] = 0x80; } break; } case ColorSpace_YUV420PSEMI: { Int8 *bufPtr = Buffer_getUserPtr(hBuf); Int y; Int bpp = ColorSpace_getBpp(ColorSpace_YUV420PSEMI); BufferGfx_Dimensions dim; BufferGfx_getDimensions(hBuf, &dim); for (y = 0; y < dim.height; y++) { memset(bufPtr, 0x0, dim.width * bpp / 8); bufPtr += dim.lineLength; } for (y = 0; y < (dim.height / 2); y++) { memset(bufPtr, 0x80, dim.width * bpp / 8); bufPtr += dim.lineLength; } break; } case ColorSpace_UYVY: { Int32 *bufPtr = (Int32*)Buffer_getUserPtr(hBuf); Int32 bufSize = Buffer_getSize(hBuf) / sizeof(Int32); Int i; /* Make sure display buffer is 4-byte aligned */ assert((((UInt32) bufPtr) & 0x3) == 0); for (i = 0; i < bufSize; i++) { bufPtr[i] = UYVY_BLACK; } break; } case ColorSpace_RGB565: { memset(Buffer_getUserPtr(hBuf), 0, Buffer_getSize(hBuf)); break; } default: Dmai_err0("Unsupported color space for _Dmai_blackFill\n"); break; } }
/****************************************************************************** * _Dmai_v4l2UserAlloc ******************************************************************************/ Int _Dmai_v4l2UserAlloc(Int fd, Int numBufs, enum v4l2_buf_type type, struct _VideoBufDesc **bufDescsPtr, BufTab_Handle hBufTab, Int topOffset, ColorSpace_Type colorSpace, Int queueBuffers) { struct v4l2_requestbuffers req; struct v4l2_format fmt; _VideoBufDesc *bufDesc; Buffer_Handle hBuf; Int bufIdx; Dmai_clear(fmt); fmt.type = type; if (ioctl(fd, VIDIOC_G_FMT, &fmt) == -1) { Dmai_err1("VIDIOC_G_FMT failed (%s)\n", strerror(errno)); return Dmai_EFAIL; } if (Buffer_getSize(BufTab_getBuf(hBufTab, 0)) < fmt.fmt.pix.width * fmt.fmt.pix.height * 2) { Dmai_err0("Supplied buffers not large enough for video standard\n"); return Dmai_EINVAL; } /* Set the actual size of the buffers allocated */ fmt.type = type; fmt.fmt.pix.sizeimage = Buffer_getSize(BufTab_getBuf(hBufTab, 0)); fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY; fmt.fmt.pix.bytesperline = fmt.fmt.pix.width; if (ioctl(fd, VIDIOC_S_FMT, &fmt) == -1) { Dmai_err1("VIDIOC_S_FMT failed (%s)\n", strerror(errno)); return Dmai_EIO; } /* * Tell the driver that we will use user allocated buffers, but don't * allocate any buffers in the driver (just the internal descriptors). */ Dmai_clear(req); req.type = type; req.count = numBufs; req.memory = V4L2_MEMORY_USERPTR; if (ioctl(fd, VIDIOC_REQBUFS, &req) == -1) { Dmai_err0("Could not allocate video display buffers\n"); return Dmai_ENOMEM; } /* The driver may return less buffers than requested */ if (req.count < numBufs || !req.count) { Dmai_err0("Insufficient device driver buffer memory\n"); return Dmai_ENOMEM; } /* Allocate space for buffer descriptors */ *bufDescsPtr = calloc(numBufs, sizeof(_VideoBufDesc)); if (*bufDescsPtr == NULL) { Dmai_err0("Failed to allocate space for buffer descriptors\n"); return Dmai_ENOMEM; } for (bufIdx = 0; bufIdx < numBufs; bufIdx++) { bufDesc = &(*bufDescsPtr)[bufIdx]; hBuf = BufTab_getBuf(hBufTab, bufIdx); if (hBuf == NULL) { Dmai_err0("Failed to get buffer from BufTab for display\n"); return Dmai_ENOMEM; } if (Buffer_getType(hBuf) != Buffer_Type_GRAPHICS) { Dmai_err0("Buffer supplied to Display not a Graphics buffer\n"); return Dmai_EINVAL; } Dmai_clear(bufDesc->v4l2buf); bufDesc->v4l2buf.index = bufIdx; bufDesc->v4l2buf.type = type; bufDesc->v4l2buf.memory = V4L2_MEMORY_USERPTR; bufDesc->v4l2buf.m.userptr = (UInt32) Buffer_getUserPtr(hBuf); bufDesc->v4l2buf.length = (fmt.fmt.pix.sizeimage + 4096) & (~0xFFF); bufDesc->hBuf = hBuf; bufDesc->used = (queueBuffers == FALSE) ? TRUE : FALSE; /* If queueBuffers is TRUE, initialize the buffers to black and queue * them into the driver. */ if (queueBuffers == TRUE) { Buffer_setNumBytesUsed(hBuf, Buffer_getSize(hBuf)); _Dmai_blackFill(hBuf); /* Queue buffer in device driver */ if (ioctl(fd, VIDIOC_QBUF, &bufDesc->v4l2buf) == -1) { Dmai_err1("VIODIC_QBUF failed (%s)\n", strerror(errno)); return Dmai_EFAIL; } } } return Dmai_EOK; }
/****************************************************************************** * writeFrameSemiPlanar ******************************************************************************/ Int writeFrameSemiPlanar(Buffer_Handle hBuf, FILE *outFile) { Int8 *yPtr, *cbcrPtr; UInt32 ySize; /* Size of Luma data */ Uint32 cbcrSize; /* Size of Chroma (cb and cr) data */ Char *colorFmt; Int y, x; BufferGfx_Dimensions dim; BufferGfx_getDimensions(hBuf, &dim); /* The three color planes are evenly spaced in the output buffer. Each * plane has been allocated a size equal to the input creation parameter * maxWidth x maxHeight. */ ySize = dim.width * dim.height; switch(BufferGfx_getColorSpace(hBuf)){ case ColorSpace_YUV420PSEMI: cbcrSize = dim.width * dim.height / 2; colorFmt = "420P"; break; default: printf("Unsupported output color space %d.\n", BufferGfx_getColorSpace(hBuf)); return -1; } /* Write Y plane */ yPtr = Buffer_getUserPtr(hBuf); if (fwrite(yPtr, 1, ySize, outFile) != ySize ) { fprintf(stderr,"Failed to write y data to disk\n"); return -1; } /* Separate Cb from CbCr interleaved and save Cb plane */ cbcrPtr = Buffer_getUserPtr(hBuf) + Buffer_getSize(hBuf) * 2/3; for (y = 0; y < dim.height / 2; y++) { for (x = 0; x < dim.width; x += 2) { if (fwrite(&cbcrPtr[x], 1, 1, outFile) != 1) { fprintf(stderr,"Failed to write data to disk\n"); return -1; } } cbcrPtr += dim.lineLength; } /* Separate Cr from CbCr interleaved and save Cr plane */ cbcrPtr = Buffer_getUserPtr(hBuf) + Buffer_getSize(hBuf) * 2 / 3; for (y = 0; y < dim.height / 2; y++) { for (x = 1; x < dim.width; x += 2) { if (fwrite(&cbcrPtr[x], 1, 1, outFile) != 1) { fprintf(stderr,"Failed to write data to disk\n"); return -1; } } cbcrPtr += dim.lineLength; } printf("Wrote %s image size %d (%dx%d) to disk\n", colorFmt, (Int) (ySize + cbcrSize), (Int) dim.width, (Int) dim.height); return 0; }
/****************************************************************************** * Resize_execute ******************************************************************************/ Int Resize_execute(Resize_Handle hResize, Buffer_Handle hSrcBuf, Buffer_Handle hDstBuf, Buffer_Handle hsDstBuf) { struct imp_convert rsz; struct rsz_channel_config rsz_chan_config; struct rsz_single_shot_config rsz_ss_config; BufferGfx_Dimensions srcDim; BufferGfx_Dimensions dstDim; BufferGfx_Dimensions sdstDim; UInt32 srcOffset; UInt32 dstOffset; UInt32 sdstOffset; UInt32 srcSize; UInt32 dstSize; assert(hResize); assert(hSrcBuf); assert(hDstBuf); Dmai_clear(rsz); BufferGfx_getDimensions(hSrcBuf, &srcDim); BufferGfx_getDimensions(hDstBuf, &dstDim); hsDstBuf?BufferGfx_getDimensions(hsDstBuf, &sdstDim):NULL; srcSize = srcDim.width * srcDim.height; dstSize = dstDim.width * dstDim.height; /* the resize operation to ColorSpace_UYVY is different from ColorSpace_YUV420PSEMI*/ if (BufferGfx_getColorSpace(hSrcBuf) == ColorSpace_UYVY) { srcOffset = srcDim.y * srcDim.lineLength + (srcDim.x << 1); dstOffset = dstDim.y * dstDim.lineLength + (dstDim.x << 1); sdstOffset = hsDstBuf?(sdstDim.y * sdstDim.lineLength + (sdstDim.x << 1)):0; rsz.in_buff.index = -1; rsz.in_buff.buf_type = IMP_BUF_IN; rsz.in_buff.offset = Buffer_getPhysicalPtr(hSrcBuf) + srcOffset; rsz.in_buff.size = Buffer_getSize(hSrcBuf); rsz.out_buff1.index = -1; rsz.out_buff1.buf_type = IMP_BUF_OUT1; rsz.out_buff1.offset = Buffer_getPhysicalPtr(hDstBuf) + dstOffset; rsz.out_buff1.size = Buffer_getSize(hDstBuf); rsz.out_buff2.index = -1; rsz.out_buff2.buf_type = IMP_BUF_OUT2; rsz.out_buff2.offset = hsDstBuf?(Buffer_getPhysicalPtr(hsDstBuf) + sdstOffset):0; rsz.out_buff2.size = hsDstBuf?Buffer_getSize(hsDstBuf):0; /* * The IPIPE requires that the memory offsets of the input and output * buffers start on 32-byte boundaries. */ assert((rsz.in_buff.offset & 0x1F) == 0); assert((rsz.out_buff1.offset & 0x1F) == 0); assert((rsz.out_buff2.offset & 0x1F) == 0); /* Start IPIPE operation */ if (ioctl(hResize->fd, RSZ_RESIZE, &rsz) == -1) { Dmai_err0("Failed RSZ_RESIZE\n"); return Dmai_EFAIL; } Buffer_setNumBytesUsed(hDstBuf, Buffer_getSize(hDstBuf)); hsDstBuf?Buffer_setNumBytesUsed(hsDstBuf, Buffer_getSize(hsDstBuf)):NULL; } else { /* configure for the ColorSpace_YUV420PSEMI*/ Dmai_clear(rsz_ss_config); rsz_chan_config.oper_mode = IMP_MODE_SINGLE_SHOT; rsz_chan_config.chain = 0; rsz_chan_config.len = 0; rsz_chan_config.config = NULL; /* to set defaults in driver */ if (ioctl(hResize->fd, RSZ_S_CONFIG, &rsz_chan_config) < 0) { Dmai_err0("Error in setting default configuration for single shot mode\n"); return Dmai_EFAIL; } /* default configuration setting in Resizer successfull */ Dmai_clear(rsz_ss_config); rsz_chan_config.oper_mode = IMP_MODE_SINGLE_SHOT; rsz_chan_config.chain = 0; rsz_chan_config.len = sizeof(struct rsz_single_shot_config); rsz_chan_config.config = &rsz_ss_config; if (ioctl(hResize->fd, RSZ_G_CONFIG, &rsz_chan_config) < 0) { Dmai_err0("Error in getting configuration from driver\n"); return Dmai_EFAIL; } /* input params are set at the resizer */ rsz_ss_config.input.image_width = srcDim.width; rsz_ss_config.input.image_height = srcDim.height; rsz_ss_config.input.ppln = rsz_ss_config.input.image_width + 8; rsz_ss_config.input.lpfr = rsz_ss_config.input.image_height + 10; rsz_ss_config.input.pix_fmt = IPIPE_420SP_Y; rsz_ss_config.output1.pix_fmt = pixFormatConversion(BufferGfx_getColorSpace(hDstBuf)); rsz_ss_config.output1.enable = 1; rsz_ss_config.output1.width = dstDim.width; rsz_ss_config.output1.height = dstDim.height; rsz_ss_config.output2.enable = 0; rsz_chan_config.oper_mode = IMP_MODE_SINGLE_SHOT; rsz_chan_config.chain = 0; rsz_chan_config.len = sizeof(struct rsz_single_shot_config); if (ioctl(hResize->fd, RSZ_S_CONFIG, &rsz_chan_config) < 0) { Dmai_err0("Error in setting default configuration for single shot mode\n"); return Dmai_EFAIL; } rsz_chan_config.oper_mode = IMP_MODE_SINGLE_SHOT; rsz_chan_config.chain = 0; rsz_chan_config.len = sizeof(struct rsz_single_shot_config); /* read again and verify */ if (ioctl(hResize->fd, RSZ_G_CONFIG, &rsz_chan_config) < 0) { Dmai_err0("Error in getting configuration from driver\n"); return Dmai_EFAIL; } /* execute for ColorSpace_YUV420PSEMI*/ Dmai_clear(rsz); //srcOffset = srcDim.y * srcDim.lineLength + (srcDim.x << 1); //dstOffset = dstDim.y * dstDim.lineLength + (dstDim.x << 1); rsz.in_buff.buf_type = IMP_BUF_IN; rsz.in_buff.index = -1; rsz.in_buff.offset = Buffer_getPhysicalPtr(hSrcBuf); //rsz.in_buff.size = Buffer_getSize(hSrcBuf); rsz.in_buff.size = srcSize; rsz.out_buff1.buf_type = IMP_BUF_OUT1; rsz.out_buff1.index = -1; rsz.out_buff1.offset = Buffer_getPhysicalPtr(hDstBuf); //rsz.out_buff1.size = Buffer_getSize(hDstBuf); rsz.out_buff1.size = dstSize; /* * The IPIPE requires that the memory offsets of the input and output * buffers start on 32-byte boundaries. */ assert((rsz.in_buff.offset & 0x1F) == 0); assert((rsz.out_buff1.offset & 0x1F) == 0); /* Start IPIPE operation */ if (ioctl(hResize->fd, RSZ_RESIZE, &rsz) == -1) { Dmai_err0("Failed RSZ_RESIZE\n"); return Dmai_EFAIL; } /* input params are set at the resizer */ rsz_ss_config.input.image_width = srcDim.width; rsz_ss_config.input.image_height = srcDim.height>>1; rsz_ss_config.input.ppln = rsz_ss_config.input.image_width + 8; rsz_ss_config.input.lpfr = rsz_ss_config.input.image_height + 10; rsz_ss_config.input.pix_fmt = IPIPE_420SP_C; rsz_ss_config.output1.pix_fmt = pixFormatConversion(BufferGfx_getColorSpace(hDstBuf)); rsz_ss_config.output1.enable = 1; rsz_ss_config.output1.width = dstDim.width; rsz_ss_config.output1.height = dstDim.height; rsz_ss_config.output2.enable = 0; rsz_chan_config.oper_mode = IMP_MODE_SINGLE_SHOT; rsz_chan_config.chain = 0; rsz_chan_config.len = sizeof(struct rsz_single_shot_config); if (ioctl(hResize->fd, RSZ_S_CONFIG, &rsz_chan_config) < 0) { Dmai_err0("Error in setting default configuration for single shot mode\n"); return Dmai_EFAIL; } rsz_chan_config.oper_mode = IMP_MODE_SINGLE_SHOT; rsz_chan_config.chain = 0; rsz_chan_config.len = sizeof(struct rsz_single_shot_config); /* read again and verify */ if (ioctl(hResize->fd, RSZ_G_CONFIG, &rsz_chan_config) < 0) { Dmai_err0("Error in getting configuration from driver\n"); return Dmai_EFAIL; } Dmai_clear(rsz); //srcOffset = srcDim.y * srcDim.lineLength + (srcDim.x << 1); //dstOffset = dstDim.y * dstDim.lineLength + (dstDim.x << 1); rsz.in_buff.buf_type = IMP_BUF_IN; rsz.in_buff.index = -1; rsz.in_buff.offset = Buffer_getPhysicalPtr(hSrcBuf) + srcSize; rsz.in_buff.size = srcSize>>1; rsz.out_buff1.buf_type = IMP_BUF_OUT1; rsz.out_buff1.index = -1; rsz.out_buff1.offset = Buffer_getPhysicalPtr(hDstBuf) + dstSize; rsz.out_buff1.size = dstSize>>1; /* * The IPIPE requires that the memory offsets of the input and output * buffers start on 32-byte boundaries. */ assert((rsz.in_buff.offset & 0x1F) == 0); assert((rsz.out_buff1.offset & 0x1F) == 0); /* Start IPIPE operation */ if (ioctl(hResize->fd, RSZ_RESIZE, &rsz) == -1) { Dmai_err0("Failed RSZ_RESIZE\n"); return Dmai_EFAIL; } Buffer_setNumBytesUsed(hDstBuf, Buffer_getNumBytesUsed(hSrcBuf)); } return Dmai_EOK; }
static GstFlowReturn create(GstPushSrc *base, GstBuffer **buf) { GstTICaptureSrc *src = (GstTICaptureSrc *)base; Buffer_Handle hDstBuf; GstBuffer *outBuf; gint ret = GST_FLOW_OK; BufferGfx_Attrs gfxAttrs = BufferGfx_Attrs_DEFAULT; Int32 width, height; GST_LOG("create begin"); /* create capture device */ if (src->hCapture == NULL) { /* set framerate based on video standard */ switch(dmai_video_std(src->video_standard)) { case VideoStd_D1_NTSC: gst_value_set_fraction(&src->framerate,30000,1001); break; case VideoStd_D1_PAL: gst_value_set_fraction(&src->framerate,25,1); break; default: gst_value_set_fraction(&src->framerate,30,1); break; } /* set width & height based on video standard */ src->cAttrs.videoStd = dmai_video_std(src->video_standard); VideoStd_getResolution(src->cAttrs.videoStd, &width, &height); width = 720; height = 576; GST_WARNING("force video size to %dx%d", src->width, src->height); src->width = width; src->height = height; gfxAttrs.dim.height = src->height; gfxAttrs.dim.width = src->width; src->cAttrs.captureDimension = &gfxAttrs.dim; if (!capture_create(src)) return GST_FLOW_ERROR; } /* Get buffer from driver */ if (Capture_get(src->hCapture, &hDstBuf)) { GST_ELEMENT_ERROR(src, RESOURCE, FAILED, ("Failed to allocate buffer\n"), (NULL)); return GST_FLOW_ERROR; } /* Create a DMAI transport buffer object to carry a DMAI buffer to * the source pad. The transport buffer knows how to release the * buffer for re-use in this element when the source pad calls * gst_buffer_unref(). */ outBuf = gst_tidmaibuffertransport_new(hDstBuf, src->hBufTab, capture_buffer_finalize, (void*)src); gst_buffer_set_data(outBuf, GST_BUFFER_DATA(outBuf), Buffer_getSize(hDstBuf)); *buf = outBuf; /* set buffer metadata */ if (G_LIKELY (ret == GST_FLOW_OK && *buf)) { GstClock *clock; GstClockTime timestamp; GST_BUFFER_OFFSET (*buf) = src->offset++; GST_BUFFER_OFFSET_END (*buf) = src->offset; /* timestamps, LOCK to get clock and base time. */ GST_OBJECT_LOCK (src); if ((clock = GST_ELEMENT_CLOCK (src))) { /* we have a clock, get base time and ref clock */ timestamp = GST_ELEMENT (src)->base_time; gst_object_ref (clock); } else { /* no clock, can't set timestamps */ timestamp = GST_CLOCK_TIME_NONE; } GST_OBJECT_UNLOCK (src); if (G_LIKELY (clock)) { /* the time now is the time of the clock minus the base time */ timestamp = gst_clock_get_time (clock) - timestamp; gst_object_unref (clock); /* if we have a framerate adjust timestamp for frame latency */ if (GST_CLOCK_TIME_IS_VALID (src->duration)) { if (timestamp > src->duration) timestamp -= src->duration; else timestamp = 0; } } /* FIXME: use the timestamp from the buffer itself! */ GST_BUFFER_TIMESTAMP (*buf) = timestamp; GST_BUFFER_DURATION (*buf) = src->duration; } /* Create caps for buffer */ GstCaps *mycaps; GstStructure *structure; mycaps = gst_caps_new_empty(); if (src->cAttrs.colorSpace == ColorSpace_UYVY) { structure = gst_structure_new( "video/x-raw-yuv", "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC('U', 'Y', 'V', 'Y'), "framerate", GST_TYPE_FRACTION, gst_value_get_fraction_numerator(&src->framerate), gst_value_get_fraction_denominator(&src->framerate), "width", G_TYPE_INT, src->width, "height", G_TYPE_INT, src->height, (gchar*) NULL); } else if(src->cAttrs.colorSpace == ColorSpace_YUV420PSEMI) { structure = gst_structure_new( "video/x-raw-yuv", "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC('N', 'V', '1', '2'), "framerate", GST_TYPE_FRACTION, gst_value_get_fraction_numerator(&src->framerate), gst_value_get_fraction_denominator(&src->framerate), "width", G_TYPE_INT, src->width, "height", G_TYPE_INT, src->height, (gchar*) NULL); } else { GST_ERROR("unsupported fourcc\n"); return FALSE; } gst_caps_append_structure(mycaps, gst_structure_copy (structure)); gst_structure_free(structure); gst_buffer_set_caps(*buf, mycaps); gst_caps_unref(mycaps); { static int fn; fn++; GST_INFO("capture frame %d", fn); } GST_LOG("create end"); return GST_FLOW_OK; }
/****************************************************************************** * gst_ticircbuffer_display * Print out a nice visual of the buffer. Legend: * W = write pointer * R = read pointer * B = write pointer and read pointer when they are at the same place * | = end of window * = = active data when there is at least one window in the buffer * - = active data when there is less than a window in the buffer * * Examples: * Write pointer after read pointer (contiguousData == TRUE): * [ R=====================|==================================W ] * Read pointer after write pointer (contiguousData == FALSE): * [==============================W R=====================|=======] * ******************************************************************************/ static void gst_ticircbuffer_display(GstTICircBuffer *circBuf) { static Char buffer[DISP_SIZE + 3]; static Int32 lastReadBufOffset = -1; static Int32 lastWriteBufOffset = -1; Int8* circBufStart = Buffer_getUserPtr(circBuf->hBuf); Int32 readOffset = circBuf->readPtr - circBufStart; Int32 writeOffset = circBuf->writePtr - circBufStart; Int32 winBufOffset = ((double)circBuf->windowSize / (double)Buffer_getSize(circBuf->hBuf) * DISP_SIZE); Int32 readBufOffset = ((double)readOffset / (double)Buffer_getSize(circBuf->hBuf) * DISP_SIZE) + 1; Int32 writeBufOffset = ((double)writeOffset / (double)Buffer_getSize(circBuf->hBuf) * DISP_SIZE) + 1; Char dataChar = '='; Int i; /* If the read or write pointers are past the end of the buffer, make sure * they get printed in the last position. */ if (readBufOffset == DISP_SIZE+1) { readBufOffset--; } if (writeBufOffset == DISP_SIZE+1) { writeBufOffset--; } /* Don't print anything out if the buffer hasn't changed significantly */ if (lastReadBufOffset > -1) { if (lastReadBufOffset == readBufOffset && lastWriteBufOffset == writeBufOffset) { return; } } lastReadBufOffset = readBufOffset; lastWriteBufOffset = writeBufOffset; /* Create a border on the ends of the buffer, and terminate the string */ buffer[0] = '['; buffer[DISP_SIZE + 1] = ']'; buffer[DISP_SIZE + 2] = '\0'; /* If less than a full window is available, represent data with "-" instead * of "=". */ if (!gst_ticircbuffer_window_available(circBuf)) { dataChar = '-'; } /* Fill in each character of the array representing the buffer */ for (i = 1; i <= DISP_SIZE; i++) { /* If we are at a read or write pointer location, generate the * character representing the pointer. */ if (i == readBufOffset && i == writeBufOffset) { buffer[i] = 'B'; } else if (i == readBufOffset) { buffer[i] = 'R'; } else if (i == writeBufOffset) { buffer[i] = 'W'; } /* Case 1: * * [ B | ] or * [==B=====================|======================================] * * If the read and write pointers are at the same location, we need * to fill all other locations with either a ' ' or an '=', depending * on if the buffer is full or empty. The only exception is the * location of the end of the window, represented by '|'. */ else if (readBufOffset == writeBufOffset) { if (i == readBufOffset + winBufOffset) { buffer[i] = '|'; } else if (!circBuf->contiguousData) { buffer[i] = dataChar; } else { buffer[i] = ' '; } } /* Case 2: * * [ R=====================|==================================W ] * * Mark active data when the write pointer is after the read pointer * If the current location is between the two pointers, we get a '=', * otherwise we get a ' '. */ else if (circBuf->contiguousData) { if (i > readBufOffset && i == readBufOffset + winBufOffset) { buffer[i] = '|'; } else if (i > readBufOffset && i < writeBufOffset) { buffer[i] = dataChar; } else { buffer[i] = ' '; } } /* Case 3: * * [==============================W R=====================|=======] * * Mark active data when the read pointer is after the write pointer * If the current location is between the two pointers, we get a ' ', * otherwise we get a '='. */ else { if (i > readBufOffset && i == readBufOffset + winBufOffset) { buffer[i] = '|'; } else if (i > readBufOffset || i < writeBufOffset) { buffer[i] = dataChar; } else { buffer[i] = ' '; } } } printf("%s\n", buffer); }
/****************************************************************************** * appMain ******************************************************************************/ Int appMain(Args * args) { IMGDEC1_Params params = Idec1_Params_DEFAULT; IMGDEC1_DynamicParams dynParams = Idec1_DynamicParams_DEFAULT; Buffer_Attrs bAttrs = Buffer_Attrs_DEFAULT; BufferGfx_Attrs gfxAttrs = BufferGfx_Attrs_DEFAULT; Time_Attrs tAttrs = Time_Attrs_DEFAULT; Idec1_Handle hId = NULL; Engine_Handle hEngine = NULL; Time_Handle hTime = NULL; Buffer_Handle hInBuf = NULL; Buffer_Handle hOutBuf = NULL; FILE *outFile = NULL; FILE *inFile = NULL; Int numBytes = 0; Int ret = Dmai_EOK; Cpu_Device device; UInt32 time; printf("Starting application...\n"); if (args->benchmark) { hTime = Time_create(&tAttrs); if (hTime == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create Time object\n"); goto cleanup; } } /* Initialize the codec engine run time */ CERuntime_init(); /* Initialize DMAI */ Dmai_init(); /* Determine which device the application is running on */ if (Cpu_getDevice(NULL, &device) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to determine target board\n"); goto cleanup; } /* Open input file */ inFile = fopen(args->inFile, "rb"); if (inFile == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to open file %s\n", args->inFile); goto cleanup; } /* Open output file */ outFile = fopen(args->outFile, "wb"); if (outFile == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create output file %s\n", args->outFile); goto cleanup; } /* Using a larger vbuf to enhance performance of file i/o */ if (setvbuf(outFile, vbuffer, _IOFBF, sizeof(vbuffer)) != 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to setvbuf on file descriptor\n"); goto cleanup; } /* Open the codec engine */ hEngine = Engine_open(args->engineName, NULL, NULL); if (hEngine == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to open codec engine %s\n", args->engineName); goto cleanup; } /* * Set output color format to UYVY or Planar output. * Here XDM_DEFUALT sets the output planar format to * the planar fromat of the encoded image. * */ switch (args->oColorSpace) { case ColorSpace_UYVY: params.forceChromaFormat = XDM_YUV_422ILE; break; case ColorSpace_NOTSET: params.forceChromaFormat = XDM_CHROMAFORMAT_DEFAULT; break; case ColorSpace_YUV444P: params.forceChromaFormat = XDM_YUV_444P; break; case ColorSpace_YUV422P: params.forceChromaFormat = XDM_YUV_422P; break; case ColorSpace_YUV420P: params.forceChromaFormat = XDM_YUV_420P; break; case ColorSpace_YUV420PSEMI: params.forceChromaFormat = XDM_YUV_420SP; break; case ColorSpace_GRAY: params.forceChromaFormat = ColorSpace_GRAY; break; default: ret = Dmai_EFAIL; fprintf(stderr,"Unsupported output color space %d.\n", args->oColorSpace); goto cleanup; } if ((device == Cpu_Device_DM365) || (device == Cpu_Device_DM368)) { params.maxHeight = VideoStd_720P_HEIGHT; params.maxWidth = VideoStd_720P_WIDTH; } if (device == Cpu_Device_DM6467) { params.maxHeight = VideoStd_720P_HEIGHT; params.maxWidth = VideoStd_720P_WIDTH; } /* Create the image decoder */ hId = Idec1_create(hEngine, args->codecName, ¶ms, &dynParams); if (hId == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create image decoder: %s\n", args->codecName); goto cleanup; } /* Align buffers to cache line boundary */ gfxAttrs.bAttrs.memParams.align = bAttrs.memParams.align = BUFSIZEALIGN; /* Use cached buffers if requested */ if (args->cache) { gfxAttrs.bAttrs.memParams.flags = bAttrs.memParams.flags = Memory_CACHED; } gfxAttrs.colorSpace = args->oColorSpace; gfxAttrs.dim.width = params.maxWidth; gfxAttrs.dim.height = params.maxHeight; gfxAttrs.dim.lineLength = BufferGfx_calcLineLength(params.maxWidth, gfxAttrs.colorSpace); /* Create an output buffer for decoded data */ hOutBuf = Buffer_create( Dmai_roundUp(Idec1_getOutBufSize(hId), BUFSIZEALIGN), BufferGfx_getBufferAttrs(&gfxAttrs)); if (hOutBuf == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create contiguous buffers\n"); goto cleanup; } /* Create an input buffer for encoded data */ hInBuf = Buffer_create(Dmai_roundUp(Idec1_getInBufSize(hId), BUFSIZEALIGN), &bAttrs); if (hInBuf == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create contiguous buffers\n"); goto cleanup; } /* Read encoded image data */ numBytes = fread(Buffer_getUserPtr(hInBuf), 1, Idec1_getInBufSize(hId), inFile); Buffer_setNumBytesUsed(hInBuf, numBytes); if (args->benchmark) { if (Time_reset(hTime) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to reset timer\n"); goto cleanup; } } if (args->cache) { /* * To meet xDAIS DMA Rule 7, when input buffers are cached, we * must writeback the cache into physical memory. Also, per DMA * Rule 7, we must invalidate the output buffer from * cache before providing it to any xDAIS algorithm. */ Memory_cacheWbInv(Buffer_getUserPtr(hInBuf), Buffer_getSize(hInBuf)); /* Per DMA Rule 7, our output buffer cache lines must be cleaned */ Memory_cacheInv(Buffer_getUserPtr(hOutBuf), Buffer_getSize(hOutBuf)); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer delta\n"); goto cleanup; } printf("Pre-process cache maintenance: %uus \n", (Uns) time); } } printf("Decoding image...\n"); /* Decode the image frame */ ret = Idec1_process(hId, hInBuf, hOutBuf); if (ret < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to decode image buffer\n"); goto cleanup; } if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer delta\n"); goto cleanup; } printf("Frame - Decode: %uus \n", (unsigned int)time); } if (args->cache) { /* Writeback the outBuf. */ Memory_cacheWb(Buffer_getUserPtr(hOutBuf), Buffer_getSize(hOutBuf)); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer delta\n"); goto cleanup; } printf("Post-process cache write back: %uus ", (Uns) time); } } /* Write decoded image to a file */ if (BufferGfx_getColorSpace(hOutBuf) == ColorSpace_UYVY){ if (writeFrameUYVY(hOutBuf, outFile) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to write image to file\n"); goto cleanup; } } else if (BufferGfx_getColorSpace(hOutBuf) == ColorSpace_YUV420PSEMI) { if (writeFrameSemiPlanar(hOutBuf, outFile) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to write image to file\n"); goto cleanup; } } else if (BufferGfx_getColorSpace(hOutBuf) == ColorSpace_YUV420P || ColorSpace_YUV422P || ColorSpace_YUV444P || ColorSpace_GRAY){ /* For XDM_GRAY ignoring the color planes */ if (args->oColorSpace == ColorSpace_GRAY){ BufferGfx_setColorSpace (hOutBuf, ColorSpace_GRAY); } if (writeFramePlanar(hOutBuf, outFile) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to write image to file\n"); goto cleanup; } } else { ret = Dmai_EFAIL; fprintf(stderr,"Invalid output colorspace.\n"); goto cleanup; } if (args->benchmark) { if (Time_total(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer total\n"); goto cleanup; } printf("Total: %uus\n", (unsigned int)time); } cleanup: /* Clean up the application */ if (hId) { Idec1_delete(hId); } if (hInBuf) { Buffer_delete(hInBuf); } if (hOutBuf) { Buffer_delete(hOutBuf); } if (hEngine) { Engine_close(hEngine); } if (hTime) { Time_delete(hTime); } if (inFile) { fclose(inFile); } if (outFile) { fclose(outFile); } printf("End of application.\n"); if (ret == Dmai_EFAIL) return 1; else return 0; }
/****************************************************************************** * appMain ******************************************************************************/ Int appMain(Args * args) { VIDENC1_Params params = Venc1_Params_DEFAULT; VIDENC1_DynamicParams dynParams = Venc1_DynamicParams_DEFAULT; BufferGfx_Attrs gfxAttrs = BufferGfx_Attrs_DEFAULT; Buffer_Attrs bAttrs = Buffer_Attrs_DEFAULT; Time_Attrs tAttrs = Time_Attrs_DEFAULT; Venc1_Handle hVe1 = NULL; FILE *outFile = NULL; FILE *reconFile = NULL; FILE *inFile = NULL; Engine_Handle hEngine = NULL; Time_Handle hTime = NULL; Bool flushed = FALSE; Bool mustExit = FALSE; BufTab_Handle hBufTab = NULL; Buffer_Handle hOutBuf = NULL; Buffer_Handle hFreeBuf = NULL; Buffer_Handle hInBuf = NULL; Buffer_Handle hReconBuf = NULL; Int numFrame = 0; Int flushCntr = 1; Int bufIdx; Int inBufSize, outBufSize; Cpu_Device device; Int numBufs; ColorSpace_Type colorSpace; UInt32 time; Int ret = Dmai_EOK; printf("Starting application...\n"); /* Initialize the codec engine run time */ CERuntime_init(); /* Initialize DMAI */ Dmai_init(); /* Determine which device the application is running on */ if (Cpu_getDevice(NULL, &device) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to determine target board\n"); goto cleanup; } if (args->benchmark) { hTime = Time_create(&tAttrs); if (hTime == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create Time object\n"); goto cleanup; } } /* Open the input file with raw yuv data */ inFile = fopen(args->inFile, "rb"); if (inFile == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to open input file %s\n", args->inFile); goto cleanup; } /* Using a larger vbuf to enhance performance of file i/o */ if (setvbuf(inFile, vbufferIn, _IOFBF, sizeof(vbufferIn)) != 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to setvbuf on input file descriptor\n"); goto cleanup; } /* Open the output file where to put encoded data */ outFile = fopen(args->outFile, "wb"); if (outFile == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to open output file %s\n", args->outFile); goto cleanup; } /* Using a larger vbuf to enhance performance of file i/o */ if (setvbuf(outFile, vbufferOut, _IOFBF, sizeof(vbufferOut)) != 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to setvbuf on output file descriptor\n"); goto cleanup; } /* Open the output file where to put reconstructed frames */ if (args->writeReconFrames) { reconFile = fopen(args->reconFile, "wb"); if (reconFile == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to open output file %s\n", args->reconFile); goto cleanup; } /* Using a larger vbuf to enhance performance of file i/o */ if (setvbuf(reconFile, vbufferRecon, _IOFBF, sizeof(vbufferRecon)) != 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to setvbuf on output file descriptor\n"); goto cleanup; } } /* Open the codec engine */ hEngine = Engine_open(args->engineName, NULL, NULL); if (hEngine == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to open codec engine: %s\n", args->engineName); goto cleanup; } /* Set up codec parameters depending on bit rate */ if (args->bitRate < 0) { /* Variable bit rate */ params.rateControlPreset = IVIDEO_NONE; /* * If variable bit rate use a bogus bit rate value (> 0) * since it will be ignored. */ params.maxBitRate = 2000000; } else { /* Constant bit rate */ params.rateControlPreset = IVIDEO_LOW_DELAY; params.maxBitRate = args->bitRate; } /* Set up codec parameters depending on device */ switch (device) { case Cpu_Device_DM6467: params.inputChromaFormat = XDM_YUV_420SP; params.reconChromaFormat = XDM_CHROMA_NA; break; case Cpu_Device_DM355: params.inputChromaFormat = XDM_YUV_422ILE; params.reconChromaFormat = XDM_YUV_420P; break; case Cpu_Device_DM365: case Cpu_Device_DM368: params.inputChromaFormat = XDM_YUV_420SP; params.reconChromaFormat = XDM_YUV_420SP; break; case Cpu_Device_DM3730: params.rateControlPreset = IVIDEO_STORAGE; params.inputChromaFormat = XDM_YUV_422ILE; break; default: params.inputChromaFormat = XDM_YUV_422ILE; break; } params.maxWidth = args->width; params.maxHeight = args->height; /* Workaround for SDOCM00068944: h264fhdvenc fails to create codec when params.dataEndianness is set as XDM_BYTE */ if(device == Cpu_Device_DM6467) { if (!strcmp(args->codecName, "h264fhdvenc")) { params.dataEndianness = XDM_LE_32; } } params.maxInterFrameInterval = 1; dynParams.targetBitRate = params.maxBitRate; dynParams.inputWidth = params.maxWidth; dynParams.inputHeight = params.maxHeight; /* Create the video encoder */ hVe1 = Venc1_create(hEngine, args->codecName, ¶ms, &dynParams); if (hVe1 == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create video encoder: %s\n", args->codecName); goto cleanup; } /* Ask the codec how much input data it needs */ inBufSize = Venc1_getInBufSize(hVe1); /* Ask the codec how much space it needs for output data */ outBufSize = Venc1_getOutBufSize(hVe1); /* Which color space to use in the graphics buffers depends on the device */ colorSpace = ((device == Cpu_Device_DM6467)|| (device == Cpu_Device_DM365) || (device == Cpu_Device_DM368)) ? ColorSpace_YUV420PSEMI : ColorSpace_UYVY; /* Align buffers to cache line boundary */ gfxAttrs.bAttrs.memParams.align = bAttrs.memParams.align = BUFSIZEALIGN; /* Use cached buffers if requested */ if (args->cache) { gfxAttrs.bAttrs.memParams.flags = bAttrs.memParams.flags = Memory_CACHED; } gfxAttrs.dim.width = args->width; gfxAttrs.dim.height = args->height; if ((device == Cpu_Device_DM6467) || (device == Cpu_Device_DM365) || (device == Cpu_Device_DM368)) { gfxAttrs.dim.height = Dmai_roundUp(gfxAttrs.dim.height, CODECHEIGHTALIGN); } gfxAttrs.dim.lineLength = BufferGfx_calcLineLength(args->width, colorSpace); gfxAttrs.colorSpace = colorSpace; if (inBufSize < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to calculate buffer attributes\n"); goto cleanup; } /* Number of input buffers required */ if(params.maxInterFrameInterval>1) { /* B frame support */ numBufs = params.maxInterFrameInterval; } else { numBufs = 1; } /* Create a table of input buffers of the size requested by the codec */ hBufTab = BufTab_create(numBufs, Dmai_roundUp(inBufSize, BUFSIZEALIGN), BufferGfx_getBufferAttrs(&gfxAttrs)); if (hBufTab == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to allocate contiguous buffers\n"); goto cleanup; } /* Set input buffer table */ Venc1_setBufTab(hVe1, hBufTab); /* Create the reconstructed frame buffer for raw yuv data */ if (args->writeReconFrames) { hReconBuf = Buffer_create(Dmai_roundUp(inBufSize, BUFSIZEALIGN), BufferGfx_getBufferAttrs(&gfxAttrs)); if (hReconBuf == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to allocate contiguous buffer\n"); goto cleanup; } } /* Create the output buffer for encoded video data */ hOutBuf = Buffer_create(Dmai_roundUp(outBufSize, BUFSIZEALIGN), &bAttrs); if (hOutBuf == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create contiguous buffer\n"); goto cleanup; } while (1) { /* Get a buffer for input */ hInBuf = BufTab_getFreeBuf(hBufTab); if (hInBuf == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get a free contiguous buffer from BufTab\n"); BufTab_print(hBufTab); goto cleanup; } if (args->benchmark) { if (Time_reset(hTime) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to reset timer\n"); goto cleanup; } } /* Read a yuv input frame */ printf("\n Frame %d: ", numFrame); if ((device == Cpu_Device_DM6467)|| (device == Cpu_Device_DM365) || (device == Cpu_Device_DM368)) { if(args->sp) { if (readFrame420SP(hInBuf, inFile, args->height) < 0) { ret = Dmai_EFAIL; goto cleanup; } } else { if (readFrame420P(hInBuf, inFile, args->height) < 0) { ret = Dmai_EFAIL; goto cleanup; } } } else { if (readFrameUYVY(hInBuf, inFile) < 0) { ret = Dmai_EFAIL; mustExit = TRUE; } } if (++numFrame == args->numFrames||mustExit == TRUE) { if(!(params.maxInterFrameInterval>1)) { /* No B-frame support */ printf("... exiting \n"); goto cleanup; } /* * When encoding a stream with B-frames, ending the processing * requires to free the buffer held by the encoder. This is done by * flushing the encoder and performing a last process() call * with a dummy input buffer. */ printf("\n... exiting with flush (B-frame stream) \n"); flushCntr = params.maxInterFrameInterval-1; flushed = TRUE; Venc1_flush(hVe1); } if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer delta\n"); goto cleanup; } printf("Read time: %uus\n", (Uns)time); } /* * Following flushing loop will iterate more than one time only * when the encoder completes processing by flushing the frames * held by the encoder. All flushed frames will be encoded as P * or I frames. */ for(bufIdx = 0; bufIdx < flushCntr; bufIdx++) { if (args->cache) { /* * To meet xDAIS DMA Rule 7, when input buffers are cached, we * must writeback the cache into physical memory. Also, per DMA * Rule 7, we must invalidate the output buffer from * cache before providing it to any xDAIS algorithm. */ Memory_cacheWbInv(Buffer_getUserPtr(hInBuf), Buffer_getSize(hInBuf)); /* Per DMA Rule 7, our output buffer cache lines must be cleaned */ Memory_cacheInv(Buffer_getUserPtr(hOutBuf), Buffer_getSize(hOutBuf)); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer delta\n"); goto cleanup; } printf("Pre-process cache maintenance: %uus \n", (Uns) time); } } /* Make sure the whole buffer is used for input */ BufferGfx_resetDimensions(hInBuf); /* Encode the video buffer */ if (Venc1_process(hVe1, hInBuf, hOutBuf) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to encode video buffer\n"); goto cleanup; } /* if encoder generated output content, free released buffer */ if (Buffer_getNumBytesUsed(hOutBuf)>0) { /* Get free buffer */ hFreeBuf = Venc1_getFreeBuf(hVe1); /* Free buffer */ BufTab_freeBuf(hFreeBuf); } /* if encoder did not generate output content */ else { /* if non B frame sequence */ /* encoder skipped frame probably exceeding target bitrate */ if (params.maxInterFrameInterval<=1) { /* free buffer */ printf(" Encoder generated 0 size frame\n"); BufTab_freeBuf(hInBuf); } } if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get encode time\n"); goto cleanup; } printf("[%d] Encode: %uus\n", numFrame, (Uns)time); } if (args->cache) { /* Writeback the outBuf. */ Memory_cacheWb(Buffer_getUserPtr(hOutBuf), Buffer_getSize(hOutBuf)); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer delta\n"); goto cleanup; } printf("Post-process cache write back: %uus \n", (Uns) time); } } /* Write the encoded frame to the file system */ if (Buffer_getNumBytesUsed(hOutBuf)) { if (fwrite(Buffer_getUserPtr(hOutBuf), Buffer_getNumBytesUsed(hOutBuf), 1, outFile) != 1) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to write encoded video data to file\n"); goto cleanup; } } /* Write the reconstructed frame to the file system */ if (args->writeReconFrames) { processReconData(Venc1_getReconBufs(hVe1), hInBuf, hReconBuf); if (Buffer_getNumBytesUsed(hReconBuf)) { if (fwrite(Buffer_getUserPtr(hReconBuf), Buffer_getNumBytesUsed(hReconBuf), 1, reconFile) != 1) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to write reconstructed frame to file\n"); goto cleanup; } } } if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; printf("Failed to get timer delta\n"); goto cleanup; } printf("File write time: %uus\n", (Uns)time); if (Time_total(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer total\n"); goto cleanup; } printf("Total: %uus\n", (Uns)time); } } /* If the codec flushing completed, exit main thread */ if (flushed) { /* Free dummy input buffer used for flushing process() calls */ printf("freeing dummy input buffer ... \n"); BufTab_freeBuf(hInBuf); break; } } cleanup: /* Clean up the application */ if (hOutBuf) { Buffer_delete(hOutBuf); } if (hReconBuf) { Buffer_delete(hReconBuf); } if (hVe1) { Venc1_delete(hVe1); } if (hBufTab) { BufTab_delete(hBufTab); } if (hEngine) { Engine_close(hEngine); } if (inFile) { fclose(inFile); } if (outFile) { fclose(outFile); } if (reconFile) { fclose(reconFile); } if (hTime) { Time_delete(hTime); } printf("End of application.\n"); if (ret == Dmai_EFAIL) return 1; else return 0; }
Void *deiThrFxn(Void *arg) { DeiEnv *envp = (DeiEnv *) arg; Void *status = THREAD_SUCCESS; Uint32 sysRegBase = 0; VIDENC1_Handle hDei = NULL; IDEI_Params deiParams; Uint16 frame_width = 0, frame_height = 0; Uint16 threshold_low = 0, threshold_high = 0; IVIDEO1_BufDescIn inBufDesc; XDM_BufDesc outBufDesc; XDAS_Int8 *outbufs[2]; XDAS_Int32 outBufSizeArray[2]; VIDENC1_InArgs inArgs; IDEI_OutArgs outArgs; Uint32 bufferSize; CMEM_AllocParams cmemPrm; Uint32 prevBufAddr, outBufAddr; Buffer_Handle cBuf, dBuf; Int ret = 0; int fd = -1; dm365mmap_params_t dm365mmap_params; pthread_mutex_t Dmai_DM365dmaLock = PTHREAD_MUTEX_INITIALIZER; /* ▼▼▼▼▼ Initialization ▼▼▼▼▼ */ DM365MM_init(); printf("\n"); /* dm365mm issue */ sysRegBase = DM365MM_mmap(0x01C40000, 0x4000); CMEM_init(); cmemPrm.type = CMEM_HEAP; cmemPrm.flags = CMEM_NONCACHED; cmemPrm.alignment = 32; prevBufAddr = (Uint32)CMEM_alloc(IN_OUT_BUF_SIZE, &cmemPrm); outBufAddr = (Uint32)CMEM_alloc(IN_OUT_BUF_SIZE, &cmemPrm); frame_width = 720; frame_height = 576; threshold_low = 16; threshold_high = 20; /* Create DEI instance */ deiParams.videncParams.size = sizeof(IDEI_Params); deiParams.frameHeight = frame_height; deiParams.frameWidth = frame_width; deiParams.inLineOffset = frame_width; deiParams.outLineOffset = (frame_width - 8); deiParams.threshold_low = threshold_low; deiParams.threshold_high = threshold_high; deiParams.inputFormat = XDM_YUV_422ILE; deiParams.outputFormat = XDM_YUV_420SP; deiParams.q_num = 1; deiParams.askIMCOPRes = 0; deiParams.sysBaseAddr = sysRegBase; hDei = VIDENC1_create(envp->hEngine, "dei", (VIDENC1_Params *)&deiParams); if(hDei == NULL) { ERR("DEI alg creation failed\n"); cleanup(THREAD_FAILURE); } fd = open("/dev/dm365mmap", O_RDWR | O_SYNC); Rendezvous_meet(envp->hRendezvousInit); /* ▲▲▲▲▲ Initialization ▲▲▲▲▲ */ while (1) { if (Fifo_get(envp->hFromCaptureFifo, &cBuf) < 0) { ERR("Failed to get buffer from capture thread\n"); cleanup(THREAD_FAILURE); } if (Fifo_get(envp->hFromDisplayFifo, &dBuf) < 0) { ERR("Failed to get buffer from display thread\n"); cleanup(THREAD_FAILURE); } inBufDesc.numBufs = 4; bufferSize = (frame_width * frame_height); inBufDesc.bufDesc[0].bufSize = bufferSize; inBufDesc.bufDesc[0].buf = (XDAS_Int8 *)Buffer_getUserPtr(cBuf); inBufDesc.bufDesc[0].accessMask = 0; inBufDesc.bufDesc[1].bufSize = bufferSize; inBufDesc.bufDesc[1].buf = (XDAS_Int8 *)(Buffer_getUserPtr(cBuf) + bufferSize); inBufDesc.bufDesc[1].accessMask = 0; inBufDesc.bufDesc[2].bufSize = bufferSize; inBufDesc.bufDesc[2].buf = (XDAS_Int8 *)prevBufAddr; inBufDesc.bufDesc[2].accessMask = 0; inBufDesc.bufDesc[3].bufSize = bufferSize; inBufDesc.bufDesc[3].buf = (XDAS_Int8 *)(prevBufAddr + bufferSize); inBufDesc.bufDesc[3].accessMask = 0; /* Output buffers */ outBufDesc.numBufs = 2; outbufs[0] = (XDAS_Int8*)outBufAddr; outbufs[1] = (XDAS_Int8*)(outBufAddr + bufferSize); outBufSizeArray[0] = bufferSize; outBufSizeArray[1] = bufferSize / 2; outBufDesc.bufSizes = outBufSizeArray; outBufDesc.bufs = outbufs; inArgs.size = sizeof(VIDENC1_InArgs); outArgs.videncOutArgs.size = sizeof(IDEI_OutArgs); ret = VIDENC1_process((VIDENC1_Handle)hDei, &inBufDesc, &outBufDesc, &inArgs, (IVIDENC1_OutArgs *)&outArgs); if (ret != VIDENC1_EOK) { ERR("DEI process failed\n"); cleanup(THREAD_FAILURE); } dm365mmap_params.src = CMEM_getPhys(outbufs[0]); dm365mmap_params.srcmode = 0; dm365mmap_params.dst = Buffer_getPhysicalPtr(dBuf); dm365mmap_params.dstmode = 0; dm365mmap_params.srcbidx = 712; dm365mmap_params.dstbidx = 704; dm365mmap_params.acnt = 704; dm365mmap_params.bcnt = 576; dm365mmap_params.ccnt = 1; dm365mmap_params.bcntrld = dm365mmap_params.bcnt; dm365mmap_params.syncmode = 1; pthread_mutex_lock(&Dmai_DM365dmaLock); if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) { ERR("memcpy: Failed to do memcpy\n"); cleanup(THREAD_FAILURE); } pthread_mutex_unlock(&Dmai_DM365dmaLock); dm365mmap_params.src = CMEM_getPhys(outbufs[1]); dm365mmap_params.srcmode = 0; dm365mmap_params.dst = Buffer_getPhysicalPtr(dBuf) + (Buffer_getSize(dBuf) * 2 / 3); dm365mmap_params.dstmode = 0; dm365mmap_params.srcbidx = 712; dm365mmap_params.dstbidx = 704; dm365mmap_params.acnt = 712; dm365mmap_params.bcnt = 570 / 2; dm365mmap_params.ccnt = 1; dm365mmap_params.bcntrld = dm365mmap_params.bcnt; dm365mmap_params.syncmode = 1; pthread_mutex_lock(&Dmai_DM365dmaLock); if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) { ERR("memcpy: Failed to do memcpy\n"); cleanup(THREAD_FAILURE); } pthread_mutex_unlock(&Dmai_DM365dmaLock); Buffer_setNumBytesUsed(dBuf, 704 * 576 * 3 / 2); dm365mmap_params.src = Buffer_getPhysicalPtr(cBuf); dm365mmap_params.srcmode = 0; dm365mmap_params.dst = prevBufAddr; dm365mmap_params.dstmode = 0; dm365mmap_params.srcbidx = 1440; dm365mmap_params.dstbidx = 1440; dm365mmap_params.acnt = 1440; dm365mmap_params.bcnt = 576; dm365mmap_params.ccnt = 1; dm365mmap_params.bcntrld = dm365mmap_params.bcnt; dm365mmap_params.syncmode = 1; pthread_mutex_lock(&Dmai_DM365dmaLock); if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) { ERR("memcpy: Failed to do memcpy\n"); cleanup(THREAD_FAILURE); } pthread_mutex_unlock(&Dmai_DM365dmaLock); /* Send buffer to display thread */ if (Fifo_put(envp->hToDisplayFifo, dBuf) < 0) { ERR("Failed to send buffer to dei thread\n"); cleanup(THREAD_FAILURE); } /* Send buffer to display thread */ if (Fifo_put(envp->hToCaptureFifo, cBuf) < 0) { ERR("Failed to send buffer to dei thread\n"); cleanup(THREAD_FAILURE); } } cleanup: Rendezvous_force(envp->hRendezvousInit); Rendezvous_meet(envp->hRendezvousCleanup); /* Delete DEI ALG instance */ VIDENC1_delete(hDei); DM365MM_ummap(sysRegBase,0x4000); DM365MM_exit(); if (fd > 0) { close(fd); } return status; }
/****************************************************************************** * main ******************************************************************************/ Int appMain(Args * args) { Buffer_Attrs bAttrs = Buffer_Attrs_DEFAULT; Loader_Attrs lAttrs = Loader_Attrs_DEFAULT; AUDDEC1_Params params = Adec1_Params_DEFAULT; AUDDEC1_DynamicParams dynParams = Adec1_DynamicParams_DEFAULT; Time_Attrs tAttrs = Time_Attrs_DEFAULT; Adec1_Handle hAd1 = NULL; Loader_Handle hLoader = NULL; Engine_Handle hEngine = NULL; Buffer_Handle hOutBuf = NULL; Time_Handle hTime = NULL; Buffer_Handle hInBuf = NULL; FILE *outFile = NULL; Int numFrame = 0; UInt32 time; Int ret = Dmai_EOK; Cpu_Device device; printf("Starting application...\n"); if (args->benchmark) { hTime = Time_create(&tAttrs); if (hTime == NULL) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to create Time object\n"); goto cleanup; } } /* Initialize the codec engine run time */ CERuntime_init(); /* Initialize DMAI */ Dmai_init(); /* Determine which device the application is running on */ if (Cpu_getDevice(NULL, &device) < 0) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to determine target board\n"); goto cleanup; } /* Open the output file */ outFile = fopen(args->outFile, "wb"); if (outFile == NULL) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to create output file %s\n", args->outFile); goto cleanup; } /* Using a larger vbuf to enhance performance of file i/o */ if (setvbuf(outFile, vbuffer, _IOFBF, sizeof(vbuffer)) != 0) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to setvbuf on file descriptor\n"); goto cleanup; } /* Open the codec engine */ hEngine = Engine_open(args->engineName, NULL, NULL); if (hEngine == NULL) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to open codec engine %s\n", args->engineName); goto cleanup; } if (device == Cpu_Device_DM365 || device == Cpu_Device_OMAP3530 || device == Cpu_Device_DM368 || device == Cpu_Device_DM3730) { params.dataEndianness = XDM_LE_16; } /* Create the AUDDEC1 based audio decoder */ hAd1 = Adec1_create(hEngine, args->codecName, ¶ms, &dynParams); if (hAd1 == NULL) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to create audio decoder\n"); goto cleanup; } /* Align buffers to cache line boundary */ bAttrs.memParams.align = lAttrs.mParams.align = BUFSIZEALIGN; /* Use cached buffers if requested */ if (args->cache) { bAttrs.memParams.flags = lAttrs.mParams.flags = Memory_CACHED; } /* Ask the codec how much input data it needs */ lAttrs.readSize = Adec1_getInBufSize(hAd1); /* Make the total ring buffer larger */ lAttrs.readBufSize = Dmai_roundUp(lAttrs.readSize * 10, BUFSIZEALIGN); /* Increase the stdio buffer size for loader for better RTDX performance */ lAttrs.vBufSize = VBUFSIZE; /* Create the file loader */ hLoader = Loader_create(args->inFile, &lAttrs); if (hLoader == NULL) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to create loader\n"); goto cleanup; } /* Create an output buffer for decoded data */ hOutBuf = Buffer_create( Dmai_roundUp(Adec1_getOutBufSize(hAd1), BUFSIZEALIGN), &bAttrs); if (hOutBuf == NULL) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to create contiguous buffers\n"); goto cleanup; } /* Prime the file loader */ Loader_prime(hLoader, &hInBuf); while (numFrame++ < args->numFrames) { if (args->benchmark) { if (Time_reset(hTime) < 0) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to reset timer\n"); goto cleanup; } } if (args->cache) { /* * To meet xDAIS DMA Rule 7, when input buffers are cached, we * must writeback the cache into physical memory. Also, per DMA * Rule 7, we must invalidate the output buffer from * cache before providing it to any xDAIS algorithm. */ Memory_cacheWbInv(Buffer_getUserPtr(hInBuf),Buffer_getSize(hInBuf)); /* Per DMA Rule 7, our output buffer cache lines must be cleaned */ Memory_cacheInv(Buffer_getUserPtr(hOutBuf),Buffer_getSize(hOutBuf)); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer delta\n"); goto cleanup; } printf("Pre-process cache maintenance: %uus ", (Uns) time); } } /* Decode the audio buffer */ ret = Adec1_process(hAd1, hInBuf, hOutBuf); if ((ret == Dmai_EFAIL)|| (ret == Dmai_EBITERROR && Buffer_getNumBytesUsed(hInBuf) == 0)) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to decode audio buffer\n"); goto cleanup; } if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to get timer delta\n"); goto cleanup; } printf("Decode: %uus ", (Uns) time); } if (args->cache) { /* Writeback the outBuf. */ Memory_cacheWb(Buffer_getUserPtr(hOutBuf), Buffer_getSize(hOutBuf)); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr, "Failed to get timer delta\n"); goto cleanup; } printf("Post-process cache write back: %uus ", (Uns) time); } } /* Load a new frame from the file system */ Loader_getFrame(hLoader, hInBuf); if (args->benchmark) { if (Time_delta(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer delta\n"); goto cleanup; } printf("Loader: %uus\n", (Uns) time); } if (Buffer_getNumBytesUsed(hOutBuf)) { if (numFrame >= args->startFrame) { printf("Frame %d: ", numFrame); if (writeFrame(hOutBuf, outFile) < 0) { ret = Dmai_EFAIL; goto cleanup; } } } if (Buffer_getUserPtr(hInBuf) == NULL) { printf("Loader returned null, clip finished\n"); break; } if (args->benchmark) { if (Time_total(hTime, &time) < 0) { ret = Dmai_EFAIL; fprintf(stderr,"Failed to get timer total\n"); goto cleanup; } printf("Total: %uus\n", (unsigned int)time); } } cleanup: /* Clean up the application */ if (hLoader) { Loader_delete(hLoader); } if (hAd1) { Adec1_delete(hAd1); } if (hOutBuf) { Buffer_delete(hOutBuf); } if (hEngine) { Engine_close(hEngine); } if (hTime) { Time_delete(hTime); } if (outFile) { fclose(outFile); } printf("End of application.\n"); if (ret == Dmai_EFAIL) return 1; else return 0; }
/****************************************************************************** * writeFramePlanar ******************************************************************************/ Int writeFramePlanar(Buffer_Handle hBuf, FILE *outFile) { Int8 *yPtr, *cbcrPtr; UInt32 ySize; /* Size of Luma data */ Uint32 cbcrSize; /* Size of Chroma (cb and cr) data */ Uint32 cbOffset, crOffSet; Char *colorFmt; BufferGfx_Dimensions dim; BufferGfx_getDimensions(hBuf, &dim); /* The three color planes are evenly spaced in the output buffer. Each * plane has been allocated a size equal to the input creation parameter * maxWidth x maxHeight. */ cbOffset = Buffer_getSize(hBuf) * 1/3; crOffSet = Buffer_getSize(hBuf) * 2/3; ySize = dim.width * dim.height; switch(BufferGfx_getColorSpace(hBuf)){ case ColorSpace_YUV444P: cbcrSize = dim.width * dim.height * 2; colorFmt = "444P"; break; case ColorSpace_YUV422P: cbcrSize = dim.width * dim.height; colorFmt = "422P"; break; case ColorSpace_YUV420P: cbcrSize = dim.width * dim.height / 2; colorFmt = "420P"; break; case ColorSpace_GRAY: cbcrSize = 0; colorFmt = "GRAY"; break; default: printf("Unsupported output color space %d.\n", BufferGfx_getColorSpace(hBuf)); return -1; } /* Write Y plane */ yPtr = Buffer_getUserPtr(hBuf); if (fwrite(yPtr, 1, ySize, outFile) != ySize ) { fprintf(stderr,"Failed to write y data to disk\n"); return -1; } /* Write Cb plane */ cbcrPtr = Buffer_getUserPtr(hBuf) + cbOffset; if (fwrite(cbcrPtr, 1, cbcrSize / 2 , outFile) != cbcrSize / 2 ) { fprintf(stderr,"Failed to write y data to disk\n"); return -1; } /* Write Cr plane */ cbcrPtr = Buffer_getUserPtr(hBuf) + crOffSet; if (fwrite(cbcrPtr, 1, cbcrSize / 2 , outFile) != cbcrSize / 2 ) { fprintf(stderr,"Failed to write y data to disk\n"); return -1; } printf("Wrote %s image size %d (%dx%d) to disk\n", colorFmt, (Int) (ySize + cbcrSize), (Int) dim.width, (Int) dim.height); return 0; }
/****************************************************************************** * Idec1_process ******************************************************************************/ Int Idec1_process(Idec1_Handle hId, Buffer_Handle hInBuf, Buffer_Handle hOutBuf) { BufferGfx_Dimensions dim; IMGDEC1_DynamicParams dynParams; IMGDEC1_InArgs inArgs; IMGDEC1_OutArgs outArgs; IMGDEC1_Status decStatus; XDM1_BufDesc inBufDesc; XDM1_BufDesc outBufDesc; XDAS_Int32 status; XDAS_Int8 * inPtr; XDAS_Int8 * outPtr; UInt32 offset = 0; UInt32 i; assert(hId); assert(hInBuf); assert(hOutBuf); assert(Buffer_getSize(hInBuf)); assert(Buffer_getUserPtr(hInBuf)); assert(Buffer_getUserPtr(hOutBuf)); assert(Buffer_getNumBytesUsed(hInBuf)); assert(Buffer_getSize(hOutBuf)); assert(Buffer_getType(hOutBuf) == Buffer_Type_GRAPHICS); BufferGfx_getDimensions(hOutBuf, &dim); inPtr = Buffer_getUserPtr(hInBuf); outPtr = Buffer_getUserPtr(hOutBuf); inArgs.size = sizeof(IMGDEC1_InArgs); inArgs.numBytes = Buffer_getNumBytesUsed(hInBuf); outArgs.size = sizeof(IMGDEC1_OutArgs); inBufDesc.numBufs = 1; outBufDesc.numBufs = hId->minNumOutBufs; inBufDesc.descs[0].buf = inPtr; inBufDesc.descs[0].bufSize = Buffer_getSize(hInBuf); for(i = 0; i < hId->minNumOutBufs; i++) { outBufDesc.descs[i].buf = (XDAS_Int8 *)((unsigned int)outPtr + offset); offset += hId->minOutBufSize[i]; outBufDesc.descs[i].bufSize = hId->minOutBufSize[i]; } /* Decode image buffer */ status = IMGDEC1_process(hId->hDecode, &inBufDesc, &outBufDesc, &inArgs, &outArgs); Buffer_setNumBytesUsed(hInBuf, outArgs.bytesConsumed); if (status != IMGDEC1_EOK) { if (XDM_ISFATALERROR(outArgs.extendedError)) { Dmai_err2("IMGDEC1_process() failed with error (%d ext: 0x%x)\n", (Int)status, (Uns) outArgs.extendedError); return Dmai_EFAIL; } else { Dmai_dbg1("IMGDEC1_process() non-fatal error 0x%x\n", (Uns) outArgs.extendedError); return Dmai_EBITERROR; } } /* Get the dynamic codec status */ decStatus.data.buf = NULL; decStatus.size = sizeof(IMGDEC1_Status); dynParams.size = sizeof(IMGDEC1_DynamicParams); status = IMGDEC1_control(hId->hDecode, XDM_GETSTATUS, &dynParams, &decStatus); if (status != IMGDEC1_EOK) { Dmai_err1("XDM_GETSTATUS failed, status=%d\n", status); return Dmai_EFAIL; } /* Set output Color Format */ switch (decStatus.outputChromaFormat) { case XDM_YUV_422ILE: BufferGfx_setColorSpace (hOutBuf, ColorSpace_UYVY); break; case XDM_YUV_420P: BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV420P); break; case XDM_YUV_422P: BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV422P); break; case XDM_YUV_444P: BufferGfx_setColorSpace (hOutBuf, ColorSpace_YUV444P); break; case XDM_GRAY: BufferGfx_setColorSpace (hOutBuf, ColorSpace_GRAY); break; default: printf("Unsupported output color space.\n"); return Dmai_EFAIL; } dim.x = dim.y = 0; dim.width = decStatus.outputWidth; dim.height = decStatus.outputHeight; dim.lineLength = decStatus.outputWidth * ColorSpace_getBpp(BufferGfx_getColorSpace(hOutBuf)) / 8; if (BufferGfx_setDimensions(hOutBuf, &dim) < 0) { Dmai_err0("Frame does not fit in allocated buffer\n"); return Dmai_EFAIL; } return Dmai_EOK; }
/****************************************************************************** * Sdec_process ******************************************************************************/ Int Sdec_process(Sdec_Handle hSd, Buffer_Handle hInBuf, Buffer_Handle hOutBuf) { SPHDEC_DynamicParams dynamicParams; SPHDEC_Status decStatus; XDM_BufDesc inBufDesc; XDM_BufDesc outBufDesc; XDAS_Int32 inBufSizeArray[1]; XDAS_Int32 outBufSizeArray[1]; XDAS_Int32 status; SPHDEC_InArgs inArgs; SPHDEC_OutArgs outArgs; XDAS_Int8 *inPtr; XDAS_Int8 *outPtr; assert(hSd); assert(hInBuf); assert(hOutBuf); assert(Buffer_getUserPtr(hInBuf)); assert(Buffer_getUserPtr(hOutBuf)); assert(Buffer_getNumBytesUsed(hInBuf)); assert(Buffer_getSize(hOutBuf)); inPtr = Buffer_getUserPtr(hInBuf); outPtr = Buffer_getUserPtr(hOutBuf); inBufSizeArray[0] = Buffer_getNumBytesUsed(hInBuf); outBufSizeArray[0] = Buffer_getSize(hOutBuf); inBufDesc.bufSizes = inBufSizeArray; inBufDesc.bufs = &inPtr; inBufDesc.numBufs = 1; outBufDesc.bufSizes = outBufSizeArray; outBufDesc.bufs = &outPtr; outBufDesc.numBufs = 1; inArgs.size = sizeof(SPHDEC_InArgs); inArgs.inBufferSize = Buffer_getNumBytesUsed(hInBuf); outArgs.size = sizeof(SPHDEC_OutArgs); /* Decode the speech buffer */ status = SPHDEC_process(hSd->hDecode, &inBufDesc, &outBufDesc, &inArgs, &outArgs); if (status != SPHDEC_EOK) { decStatus.size = sizeof(SPHDEC_Status); dynamicParams.size = sizeof(SPHDEC_DynamicParams); status = SPHDEC_control(hSd->hDecode, XDM_GETSTATUS, &dynamicParams, &decStatus); if (status != SPHDEC_EOK) { Dmai_err1("XDM_GETSTATUS failed, status=%d\n", status); return Dmai_EFAIL; } if (status == SPHDEC_ERUNTIME || XDM_ISFATALERROR(decStatus.extendedError)) { Dmai_err2("SPHDEC_process() failed with error (%d ext: 0x%x)\n", (Int)status, (Uns) decStatus.extendedError); return Dmai_EFAIL; } else { Dmai_dbg1("SPHDEC_process() non-fatal error 0x%x\n", (Uns) decStatus.extendedError); return Dmai_EBITERROR; } } /* A fixed x2 decompression ratio, only works for g711 */ Buffer_setNumBytesUsed(hOutBuf, Buffer_getNumBytesUsed(hInBuf) * 2); return Dmai_EOK; }